Fix travis.yml

.travis.yml

@@ -223,10 +223,6 @@ script:
   - ./unit_tests/util-tests
   - ./unit_tests/server-tests
   - ./unit_tests/partition-tests
-  - |
-    if [ -n "${ENABLE_NODE_BINDINGS}" ] && [ -z "${ENABLE_SANITIZER}" ]; then
-      npm run nodejs-tests
-    fi
   - popd
   - yarn test
 

CHANGELOG.md

@@ -10,8 +10,6 @@
       - .osrm.datasource_index file was removed. Data is now part of .osrm.geometries.
       - .osrm.edge_lookup was removed. The option `--generate-edge-lookup` does nothing now.
       - `osrm-contract` does not depend on the `.osrm.fileIndex` file anymore
-    - Profiles
-      - Added `force_split_edges` flag to global properties. True value guarantees that segment_function will be called for all segments, but also could double memory consumption
 
 # 5.6.3
   - Changes from 5.6.0

CMakeLists.txt

@@ -303,8 +303,6 @@ endif()
 if (ENABLE_SANITIZER)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
   set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} -fsanitize=address")
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
 endif()
 
 # Configuring compilers

cmake/NodeJS.cmake

@@ -1,627 +0,0 @@
-# Vendored NodeJs.cmake to bootstrap our C++ build without
-# having the user to install Node modules via `npm install`.
-#
-# Update via:  ../node_modules/.bin/ncmake update
-
-
-# Defaults for standard Node.js builds
-set(NODEJS_DEFAULT_URL https://nodejs.org/download/release)
-set(NODEJS_DEFAULT_VERSION installed)
-set(NODEJS_VERSION_FALLBACK latest)
-set(NODEJS_DEFAULT_NAME node)
-set(NODEJS_DEFAULT_CHECKSUM SHASUMS256.txt)
-set(NODEJS_DEFAULT_CHECKTYPE SHA256)
-
-include(CMakeParseArguments)
-
-# Find a path by walking upward from a base directory until the path is
-# found. Sets the variable ${PATH} to False if the path can't
-# be determined
-function(find_path_parent NAME BASE PATH)
-    set(ROOT ${BASE})
-    set(${PATH} ${ROOT}/${NAME} PARENT_SCOPE)
-    set(DRIVE "^[A-Za-z]?:?/$")
-    while(NOT ROOT MATCHES ${DRIVE} AND NOT EXISTS ${ROOT}/${NAME})
-        get_filename_component(ROOT ${ROOT} DIRECTORY)
-        set(${PATH} ${ROOT}/${NAME} PARENT_SCOPE)
-    endwhile()
-    if(ROOT MATCHES ${DRIVE})
-        set(${PATH} False PARENT_SCOPE)
-    endif()
-endfunction()
-
-# Shortcut for finding standard node module locations
-macro(find_nodejs_module NAME BASE PATH)
-    find_path_parent(node_modules/${NAME} ${BASE} ${PATH})
-endmacro()
-
-# Download with a bit of nice output (without spewing progress)
-function(download_file URL)
-    message(STATUS "Downloading: ${URL}")
-    file(DOWNLOAD
-        ${URL}
-        ${ARGN}
-    )
-endfunction()
-
-# Embedded win_delay_load_hook file so that this file can be copied
-# into projects directly (recommended practice)
-function(nodejs_generate_delayload_hook OUTPUT)
-    file(WRITE  ${OUTPUT} "")
-    file(APPEND ${OUTPUT} "/*\n")
-    file(APPEND ${OUTPUT} " * When this file is linked to a DLL, it sets up a delay-load hook that\n")
-    file(APPEND ${OUTPUT} " * intervenes when the DLL is trying to load 'node.exe' or 'iojs.exe'\n")
-    file(APPEND ${OUTPUT} " * dynamically. Instead of trying to locate the .exe file it'll just return\n")
-    file(APPEND ${OUTPUT} " * a handle to the process image.\n")
-    file(APPEND ${OUTPUT} " *\n")
-    file(APPEND ${OUTPUT} " * This allows compiled addons to work when node.exe or iojs.exe is renamed.\n")
-    file(APPEND ${OUTPUT} " */\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "#ifdef _MSC_VER\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "#ifndef DELAYIMP_INSECURE_WRITABLE_HOOKS\n")
-    file(APPEND ${OUTPUT} "#define DELAYIMP_INSECURE_WRITABLE_HOOKS\n")
-    file(APPEND ${OUTPUT} "#endif\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "#ifndef WIN32_LEAN_AND_MEAN\n")
-    file(APPEND ${OUTPUT} "#define WIN32_LEAN_AND_MEAN\n")
-    file(APPEND ${OUTPUT} "#endif\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "#include <windows.h>\n")
-    file(APPEND ${OUTPUT} "#include <Shlwapi.h>\n")
-    file(APPEND ${OUTPUT} "#include <delayimp.h>\n")
-    file(APPEND ${OUTPUT} "#include <string.h>\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "static FARPROC WINAPI load_exe_hook(unsigned int event, DelayLoadInfo* info) {\n")
-    file(APPEND ${OUTPUT} "  if (event != dliNotePreLoadLibrary) return NULL;\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "  if (_stricmp(info->szDll, \"iojs.exe\") != 0 &&\n")
-    file(APPEND ${OUTPUT} "      _stricmp(info->szDll, \"node.exe\") != 0 &&\n")
-    file(APPEND ${OUTPUT} "      _stricmp(info->szDll, \"node.dll\") != 0)\n")
-    file(APPEND ${OUTPUT} "    return NULL;\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "  // Get a handle to the current process executable.\n")
-    file(APPEND ${OUTPUT} "  HMODULE processModule = GetModuleHandle(NULL);\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "  // Get the path to the executable.\n")
-    file(APPEND ${OUTPUT} "  TCHAR processPath[_MAX_PATH];\n")
-    file(APPEND ${OUTPUT} "  GetModuleFileName(processModule, processPath, _MAX_PATH);\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "  // Get the name of the current executable.\n")
-    file(APPEND ${OUTPUT} "  LPSTR processName = PathFindFileName(processPath);\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "  // If the current process is node or iojs, then just return the proccess \n")
-    file(APPEND ${OUTPUT} "  // module.\n")
-    file(APPEND ${OUTPUT} "  if (_stricmp(processName, \"node.exe\") == 0 ||\n")
-    file(APPEND ${OUTPUT} "      _stricmp(processName, \"iojs.exe\") == 0) {\n")
-    file(APPEND ${OUTPUT} "    return (FARPROC) processModule;\n")
-    file(APPEND ${OUTPUT} "  }\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "  // If it is another process, attempt to load 'node.dll' from the same \n")
-    file(APPEND ${OUTPUT} "  // directory.\n")
-    file(APPEND ${OUTPUT} "  PathRemoveFileSpec(processPath);\n")
-    file(APPEND ${OUTPUT} "  PathAppend(processPath, \"node.dll\");\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "  HMODULE nodeDllModule = GetModuleHandle(processPath);\n")
-    file(APPEND ${OUTPUT} "  if(nodeDllModule != NULL) {\n")
-    file(APPEND ${OUTPUT} "    // This application has a node.dll in the same directory as the executable,\n")
-    file(APPEND ${OUTPUT} "    // use that.\n")
-    file(APPEND ${OUTPUT} "    return (FARPROC) nodeDllModule;\n")
-    file(APPEND ${OUTPUT} "  }\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "  // Fallback to the current executable, which must statically link to \n")
-    file(APPEND ${OUTPUT} "  // node.lib\n")
-    file(APPEND ${OUTPUT} "  return (FARPROC) processModule;\n")
-    file(APPEND ${OUTPUT} "}\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "PfnDliHook __pfnDliNotifyHook2 = load_exe_hook;\n")
-    file(APPEND ${OUTPUT} "\n")
-    file(APPEND ${OUTPUT} "#endif\n")
-endfunction()
-
-# Sets up a project to build Node.js native modules
-# - Downloads required dependencies and unpacks them to the build directory.
-#   Internet access is required the first invocation but not after (
-#   provided the download is successful)
-# - Sets up several variables for building against the downloaded
-#   dependencies
-# - Guarded to prevent multiple executions, so a single project hierarchy
-#   will only call this once
-function(nodejs_init)
-    # Prevents this function from executing more than once
-    if(NODEJS_INIT)
-        return()
-    endif()
-
-    # Regex patterns used by the init function for component extraction
-    set(HEADERS_MATCH "^([A-Fa-f0-9]+)[ \t]+([^-]+)-(headers|v?[0-9.]+)-(headers|v?[0-9.]+)([.]tar[.]gz)$")
-    set(LIB32_MATCH "(^[0-9A-Fa-f]+)[\t ]+(win-x86)?(/)?([^/]*)(.lib)$")
-    set(LIB64_MATCH "(^[0-9A-Fa-f]+)[\t ]+(win-)?(x64/)(.*)(.lib)$")
-
-    # Parse function arguments
-    cmake_parse_arguments(nodejs_init
-        "" "URL;NAME;VERSION;CHECKSUM;CHECKTYPE" "" ${ARGN}
-    )
-
-    # Allow the download URL to be overridden by command line argument
-    # NODEJS_URL
-    if(NODEJS_URL)
-        set(URL ${NODEJS_URL})
-    else()
-        # Use the argument if specified, falling back to the default
-        set(URL ${NODEJS_DEFAULT_URL})
-        if(nodejs_init_URL)
-            set(URL ${nodejs_init_URL})
-        endif()
-    endif()
-
-    # Allow name to be overridden by command line argument NODEJS_NAME
-    if(NODEJS_NAME)
-        set(NAME ${NODEJS_NAME})
-    else()
-        # Use the argument if specified, falling back to the default
-        set(NAME ${NODEJS_DEFAULT_NAME})
-        if(nodejs_init_NAME)
-            set(NAME ${nodejs_init_NAME})
-        endif()
-    endif()
-
-    # Allow the checksum file to be overridden by command line argument
-    # NODEJS_CHECKSUM
-    if(NODEJS_CHECKSUM)
-        set(CHECKSUM ${NODEJS_CHECKSUM})
-    else()
-        # Use the argument if specified, falling back to the default
-        set(CHECKSUM ${NODEJS_DEFAULT_CHECKSUM})
-        if(nodejs_init_CHECKSUM)
-            set(CHECKSUM ${nodejs_init_CHECKSUM})
-        endif()
-    endif()
-
-    # Allow the checksum type to be overriden by the command line argument
-    # NODEJS_CHECKTYPE
-    if(NODEJS_CHECKTYPE)
-        set(CHECKTYPE ${NODEJS_CHECKTYPE})
-    else()
-        # Use the argument if specified, falling back to the default
-        set(CHECKTYPE ${NODEJS_DEFAULT_CHECKTYPE})
-        if(nodejs_init_CHECKTYPE)
-            set(CHECKTYPE ${nodejs_init_CHECKTYPE})
-        endif()
-    endif()
-
-    # Allow the version to be overridden by the command line argument
-    # NODEJS_VERSION
-    if(NODEJS_VERSION)
-        set(VERSION ${NODEJS_VERSION})
-    else()
-        # Use the argument if specified, falling back to the default
-        set(VERSION ${NODEJS_DEFAULT_VERSION})
-        if(nodejs_init_VERSION)
-            set(VERSION ${nodejs_init_VERSION})
-        endif()
-    endif()
-
-    # "installed" is a special version that tries to use the currently
-    # installed version (determined by running node)
-    set(NODEJS_INSTALLED False CACHE BOOL "Node.js install status" FORCE)
-    if(VERSION STREQUAL "installed")
-        if(NOT NAME STREQUAL ${NODEJS_DEFAULT_NAME})
-            message(FATAL_ERROR
-                "'Installed' version identifier can only be used with"
-                "the core Node.js library"
-            )
-        endif()
-        # Fall back to the "latest" version if node isn't installed
-        set(VERSION ${NODEJS_VERSION_FALLBACK})
-        find_program(NODEJS_BINARY NAMES node nodejs)
-        if(NODEJS_BINARY)
-            execute_process(
-                COMMAND ${NODEJS_BINARY} --version
-                RESULT_VARIABLE INSTALLED_VERSION_RESULT
-                OUTPUT_VARIABLE INSTALLED_VERSION
-                OUTPUT_STRIP_TRAILING_WHITESPACE
-            )
-            if(INSTALLED_VERSION_RESULT STREQUAL "0")
-                set(NODEJS_INSTALLED True CACHE BOOL
-                    "Node.js install status" FORCE
-                )
-                set(VERSION ${INSTALLED_VERSION})
-            endif()
-        endif()
-    endif()
-
-    # Create a temporary download directory
-    set(TEMP ${CMAKE_CURRENT_BINARY_DIR}/temp)
-    if(EXISTS ${TEMP})
-        file(REMOVE_RECURSE ${TEMP})
-    endif()
-    file(MAKE_DIRECTORY ${TEMP})
-
-    # Unless the target is special version "latest", the parameters
-    # necessary to construct the root path are known
-    if(NOT VERSION STREQUAL "latest")
-        set(ROOT ${CMAKE_CURRENT_BINARY_DIR}/${NAME}/${VERSION})
-        # Extract checksums from the existing checksum file
-        set(CHECKSUM_TARGET ${ROOT}/CHECKSUM)
-    endif()
-
-    # If we're trying to determine the version or we haven't saved the
-    # checksum file for this version, download it from the specified server
-    if(VERSION STREQUAL "latest" OR
-      (DEFINED ROOT AND NOT EXISTS ${ROOT}/CHECKSUM))
-        if(DEFINED ROOT)
-            # Clear away the old checksum in case the new one is different
-            # and/or it fails to download
-            file(REMOVE ${ROOT}/CHECKSUM)
-        endif()
-        file(REMOVE ${TEMP}/CHECKSUM)
-        download_file(
-            ${URL}/${VERSION}/${CHECKSUM}
-            ${TEMP}/CHECKSUM
-            INACTIVITY_TIMEOUT 10
-            STATUS CHECKSUM_STATUS
-        )
-        list(GET CHECKSUM_STATUS 0 CHECKSUM_STATUS)
-        if(CHECKSUM_STATUS GREATER 0)
-            file(REMOVE ${TEMP}/CHECKSUM)
-            message(FATAL_ERROR
-                "Unable to download checksum file"
-            )
-        endif()
-        # Extract checksums from the temporary file
-        set(CHECKSUM_TARGET ${TEMP}/CHECKSUM)
-    endif()
-
-    # Extract the version, name, header archive and archive checksum
-    # from the file. This first extract is what defines / specifies the
-    # actual version number and name.
-    file(STRINGS
-        ${CHECKSUM_TARGET} HEADERS_CHECKSUM
-        REGEX ${HEADERS_MATCH}
-        LIMIT_COUNT 1
-    )
-    if(NOT HEADERS_CHECKSUM)
-        file(REMOVE ${TEMP}/CHECKSUM)
-        if(DEFINED ROOT)
-            file(REMOVE ${ROOT}/CHECKSUM)
-        endif()
-        message(FATAL_ERROR "Unable to extract header archive checksum")
-    endif()
-    string(REGEX MATCH ${HEADERS_MATCH} HEADERS_CHECKSUM ${HEADERS_CHECKSUM})
-    set(HEADERS_CHECKSUM ${CMAKE_MATCH_1})
-    set(NAME ${CMAKE_MATCH_2})
-    if(CMAKE_MATCH_3 STREQUAL "headers")
-        set(VERSION ${CMAKE_MATCH_4})
-    else()
-        set(VERSION ${CMAKE_MATCH_3})
-    endif()
-    set(HEADERS_ARCHIVE
-        ${CMAKE_MATCH_2}-${CMAKE_MATCH_3}-${CMAKE_MATCH_4}${CMAKE_MATCH_5}
-    )
-    # Make sure that the root directory exists, and that the checksum
-    # file has been moved over from temp
-    if(DEFINED ROOT)
-        set(OLD_ROOT ${ROOT})
-    endif()
-    set(ROOT ${CMAKE_CURRENT_BINARY_DIR}/${NAME}/${VERSION})
-    if(DEFINED OLD_ROOT AND NOT ROOT STREQUAL "${OLD_ROOT}")
-        file(REMOVE ${TEMP}/CHECKSUM)
-        file(REMOVE ${ROOT}/CHECKSUM)
-        message(FATAL_ERROR "Version/Name mismatch")
-    endif()
-    file(MAKE_DIRECTORY ${ROOT})
-    if(EXISTS ${TEMP}/CHECKSUM)
-        file(REMOVE ${ROOT}/CHECKSUM)
-        file(RENAME ${TEMP}/CHECKSUM ${ROOT}/CHECKSUM)
-    endif()
-
-    # Now that its fully resolved, report the name and version of Node.js being
-    # used
-    message(STATUS "NodeJS: Using ${NAME}, version ${VERSION}")
-
-    # Download the headers for the version being used
-    # Theoretically, these could be found by searching the installed
-    # system, but in practice, this can be error prone. They're provided
-    # on the download servers, so just use the ones there.
-    if(NOT EXISTS ${ROOT}/include)
-        file(REMOVE ${TEMP}/${HEADERS_ARCHIVE})
-        download_file(
-            ${URL}/${VERSION}/${HEADERS_ARCHIVE}
-            ${TEMP}/${HEADERS_ARCHIVE}
-            INACTIVITY_TIMEOUT 10
-            EXPECTED_HASH ${CHECKTYPE}=${HEADERS_CHECKSUM}
-            STATUS HEADERS_STATUS
-        )
-        list(GET HEADERS_STATUS 0 HEADERS_STATUS)
-        if(HEADER_STATUS GREATER 0)
-            file(REMOVE ${TEMP}/${HEADERS_ARCHIVE})
-            message(FATAL_ERROR "Unable to download Node.js headers")
-        endif()
-        execute_process(
-            COMMAND ${CMAKE_COMMAND} -E tar xfz ${TEMP}/${HEADERS_ARCHIVE}
-            WORKING_DIRECTORY ${TEMP}
-        )
-
-        # This adapts the header extraction to support a number of different
-        # header archive contents in addition to the one used by the
-        # default Node.js library
-        unset(NODEJS_HEADERS_PATH CACHE)
-        find_path(NODEJS_HEADERS_PATH
-            NAMES src include
-            PATHS
-                ${TEMP}/${NAME}-${VERSION}-headers
-                ${TEMP}/${NAME}-${VERSION}
-                ${TEMP}/${NODEJS_DEFAULT_NAME}-${VERSION}-headers
-                ${TEMP}/${NODEJS_DEFAULT_NAME}-${VERSION}
-                ${TEMP}/${NODEJS_DEFAULT_NAME}
-                ${TEMP}
-            NO_DEFAULT_PATH
-        )
-        if(NOT NODEJS_HEADERS_PATH)
-            message(FATAL_ERROR "Unable to find extracted headers folder")
-        endif()
-
-        # Move the headers into a standard location with a standard layout
-        file(REMOVE ${TEMP}/${HEADERS_ARCHIVE})
-        file(REMOVE_RECURSE ${ROOT}/include)
-        if(EXISTS ${NODEJS_HEADERS_PATH}/include/node)
-            file(RENAME ${NODEJS_HEADERS_PATH}/include/node ${ROOT}/include)
-        elseif(EXISTS ${NODEJS_HEADERS_PATH}/src)
-            file(MAKE_DIRECTORY ${ROOT}/include)
-            if(NOT EXISTS ${NODEJS_HEADERS_PATH}/src)
-                file(REMOVE_RECURSE ${ROOT}/include)
-                message(FATAL_ERROR "Unable to find core headers")
-            endif()
-            file(COPY ${NODEJS_HEADERS_PATH}/src/
-                DESTINATION ${ROOT}/include
-            )
-            if(NOT EXISTS ${NODEJS_HEADERS_PATH}/deps/uv/include)
-                file(REMOVE_RECURSE ${ROOT}/include)
-                message(FATAL_ERROR "Unable to find libuv headers")
-            endif()
-            file(COPY ${NODEJS_HEADERS_PATH}/deps/uv/include/
-                DESTINATION ${ROOT}/include
-            )
-            if(NOT EXISTS ${NODEJS_HEADERS_PATH}/deps/v8/include)
-                file(REMOVE_RECURSE ${ROOT}/include)
-                message(FATAL_ERROR "Unable to find v8 headers")
-            endif()
-            file(COPY ${NODEJS_HEADERS_PATH}/deps/v8/include/
-                DESTINATION ${ROOT}/include
-            )
-            if(NOT EXISTS ${NODEJS_HEADERS_PATH}/deps/zlib)
-                file(REMOVE_RECURSE ${ROOT}/include)
-                message(FATAL_ERROR "Unable to find zlib headers")
-            endif()
-            file(COPY ${NODEJS_HEADERS_PATH}/deps/zlib/
-                DESTINATION ${ROOT}/include
-            )
-        endif()
-        file(REMOVE_RECURSE ${NODEJS_HEADERS_PATH})
-        unset(NODEJS_HEADERS_PATH CACHE)
-    endif()
-
-    # Only download the libraries on windows, since its the only place
-    # its necessary. Note, this requires rerunning CMake if moving
-    # a module from one platform to another (should happen automatically
-    # with most generators)
-    if(WIN32)
-        # Download the win32 library for linking
-        file(STRINGS
-            ${ROOT}/CHECKSUM LIB32_CHECKSUM
-            LIMIT_COUNT 1
-            REGEX ${LIB32_MATCH}
-        )
-        if(NOT LIB32_CHECKSUM)
-            message(FATAL_ERROR "Unable to extract x86 library checksum")
-        endif()
-        string(REGEX MATCH ${LIB32_MATCH} LIB32_CHECKSUM ${LIB32_CHECKSUM})
-        set(LIB32_CHECKSUM ${CMAKE_MATCH_1})
-        set(LIB32_PATH     win-x86)
-        set(LIB32_NAME     ${CMAKE_MATCH_4}${CMAKE_MATCH_5})
-        set(LIB32_TARGET   ${CMAKE_MATCH_2}${CMAKE_MATCH_3}${LIB32_NAME})
-        if(NOT EXISTS ${ROOT}/${LIB32_PATH})
-            file(REMOVE_RECURSE ${TEMP}/${LIB32_PATH})
-            download_file(
-               ${URL}/${VERSION}/${LIB32_TARGET}
-               ${TEMP}/${LIB32_PATH}/${LIB32_NAME}
-               INACTIVITY_TIMEOUT 10
-               EXPECTED_HASH ${CHECKTYPE}=${LIB32_CHECKSUM}
-               STATUS LIB32_STATUS
-            )
-            list(GET LIB32_STATUS 0 LIB32_STATUS)
-            if(LIB32_STATUS GREATER 0)
-                message(FATAL_ERROR
-                    "Unable to download Node.js windows library (32-bit)"
-                )
-            endif()
-            file(REMOVE_RECURSE ${ROOT}/${LIB32_PATH})
-            file(MAKE_DIRECTORY ${ROOT}/${LIB32_PATH})
-            file(RENAME
-                ${TEMP}/${LIB32_PATH}/${LIB32_NAME}
-                ${ROOT}/${LIB32_PATH}/${LIB32_NAME}
-            )
-            file(REMOVE_RECURSE ${TEMP}/${LIB32_PATH})
-        endif()
-
-        # Download the win64 library for linking
-        file(STRINGS
-            ${ROOT}/CHECKSUM LIB64_CHECKSUM
-            LIMIT_COUNT 1
-            REGEX ${LIB64_MATCH}
-        )
-        if(NOT LIB64_CHECKSUM)
-            message(FATAL_ERROR "Unable to extract x64 library checksum")
-        endif()
-        string(REGEX MATCH ${LIB64_MATCH} LIB64_CHECKSUM ${LIB64_CHECKSUM})
-        set(LIB64_CHECKSUM ${CMAKE_MATCH_1})
-        set(LIB64_PATH     win-x64)
-        set(LIB64_NAME     ${CMAKE_MATCH_4}${CMAKE_MATCH_5})
-        set(LIB64_TARGET   ${CMAKE_MATCH_2}${CMAKE_MATCH_3}${LIB64_NAME})
-        if(NOT EXISTS ${ROOT}/${LIB64_PATH})
-            file(REMOVE_RECURSE ${TEMP}/${LIB64_PATH})
-            download_file(
-               ${URL}/${VERSION}/${LIB64_TARGET}
-               ${TEMP}/${LIB64_PATH}/${LIB64_NAME}
-               INACTIVITY_TIMEOUT 10
-               EXPECTED_HASH ${CHECKTYPE}=${LIB64_CHECKSUM}
-               STATUS LIB64_STATUS
-            )
-            list(GET LIB64_STATUS 0 LIB64_STATUS)
-            if(LIB64_STATUS GREATER 0)
-                message(FATAL_ERROR
-                    "Unable to download Node.js windows library (64-bit)"
-                )
-            endif()
-            file(REMOVE_RECURSE ${ROOT}/${LIB64_PATH})
-            file(MAKE_DIRECTORY ${ROOT}/${LIB64_PATH})
-            file(RENAME
-                ${TEMP}/${LIB64_PATH}/${LIB64_NAME}
-                ${ROOT}/${LIB64_PATH}/${LIB64_NAME}
-            )
-            file(REMOVE_RECURSE ${TEMP}/${LIB64_PATH})
-        endif()
-    endif()
-
-    # The downloaded headers should always be set for inclusion
-    list(APPEND INCLUDE_DIRS ${ROOT}/include)
-
-    # Look for the NAN module, and add it to the includes
-    find_nodejs_module(
-        nan
-        ${CMAKE_CURRENT_SOURCE_DIR}
-        NODEJS_NAN_DIR
-    )
-    if(NODEJS_NAN_DIR)
-        list(APPEND INCLUDE_DIRS ${NODEJS_NAN_DIR})
-    endif()
-
-    # Under windows, we need a bunch of libraries (due to the way
-    # dynamic linking works)
-    if(WIN32)
-        # Generate and use a delay load hook to allow the node binary
-        # name to be changed while still loading native modules
-        set(DELAY_LOAD_HOOK ${CMAKE_CURRENT_BINARY_DIR}/win_delay_load_hook.c)
-        nodejs_generate_delayload_hook(${DELAY_LOAD_HOOK})
-        set(SOURCES ${DELAY_LOAD_HOOK})
-
-        # Necessary flags to get delayload working correctly
-        list(APPEND LINK_FLAGS
-            "-IGNORE:4199"
-            "-DELAYLOAD:iojs.exe"
-            "-DELAYLOAD:node.exe"
-            "-DELAYLOAD:node.dll"
-        )
-
-        # Core system libraries used by node
-        list(APPEND LIBRARIES
-            kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib
-            advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib
-            odbc32.lib Shlwapi.lib DelayImp.lib
-        )
-
-        # Also link to the node stub itself (downloaded above)
-        if(CMAKE_CL_64)
-            list(APPEND LIBRARIES ${ROOT}/${LIB64_PATH}/${LIB64_NAME})
-        else()
-            list(APPEND LIBRARIES ${ROOT}/${LIB32_PATH}/${LIB32_NAME})
-        endif()
-    else()
-        # Non-windows platforms should use these flags
-        list(APPEND DEFINITIONS _LARGEFILE_SOURCE _FILE_OFFSET_BITS=64)
-    endif()
-
-    # Special handling for OSX / clang to allow undefined symbols
-    # Define is required by node on OSX
-    if(APPLE)
-        list(APPEND LINK_FLAGS "-undefined dynamic_lookup")
-        list(APPEND DEFINITIONS _DARWIN_USE_64_BIT_INODE=1)
-    endif()
-
-    # Export all settings for use as arguments in the rest of the build
-    set(NODEJS_VERSION ${VERSION} PARENT_SCOPE)
-    set(NODEJS_SOURCES ${SOURCES} PARENT_SCOPE)
-    set(NODEJS_INCLUDE_DIRS ${INCLUDE_DIRS} PARENT_SCOPE)
-    set(NODEJS_LIBRARIES ${LIBRARIES} PARENT_SCOPE)
-    set(NODEJS_LINK_FLAGS ${LINK_FLAGS} PARENT_SCOPE)
-    set(NODEJS_DEFINITIONS ${DEFINITIONS} PARENT_SCOPE)
-
-    # Prevents this function from executing more than once
-    set(NODEJS_INIT TRUE PARENT_SCOPE)
-endfunction()
-
-# Helper function for defining a node module
-# After nodejs_init, all of the settings and dependencies necessary to do
-# this yourself are defined, but this helps make sure everything is configured
-# correctly. Feel free to use it as a model to do this by hand (or to
-# tweak this configuration if you need something custom).
-function(add_nodejs_module NAME)
-    # Validate name parameter (must be a valid C identifier)
-    string(MAKE_C_IDENTIFIER ${NAME} ${NAME}_SYMBOL_CHECK)
-    if(NOT "${NAME}" STREQUAL "${${NAME}_SYMBOL_CHECK}")
-        message(FATAL_ERROR
-            "Module name must be a valid C identifier. "
-            "Suggested alternative: '${${NAME}_SYMBOL_CHECK}'"
-        )
-    endif()
-    # Make sure node is initialized (variables set) before defining the module
-    if(NOT NODEJS_INIT)
-        message(FATAL_ERROR
-            "Node.js has not been initialized. "
-            "Call nodejs_init before adding any modules"
-        )
-    endif()
-    # In order to match node-gyp, we need to build into type specific folders
-    # ncmake takes care of this, but be sure to set CMAKE_BUILD_TYPE yourself
-    # if invoking CMake directly
-    if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
-        message(FATAL_ERROR
-            "Configuration type must be specified. "
-            "Set CMAKE_BUILD_TYPE or use a different generator"
-        )
-    endif()
-
-    # A node module is a shared library
-    add_library(${NAME} SHARED ${NODEJS_SOURCES} ${ARGN})
-    # Add compiler defines for the module
-    # Two helpful ones:
-    # MODULE_NAME must match the name of the build library, define that here
-    # ${NAME}_BUILD is for symbol visibility under windows
-    string(TOUPPER "${NAME}_BUILD" ${NAME}_BUILD_DEF)
-    target_compile_definitions(${NAME}
-        PRIVATE MODULE_NAME=${NAME}
-        PRIVATE ${${NAME}_BUILD_DEF}
-        PUBLIC ${NODEJS_DEFINITIONS}
-    )
-    # This properly defines includes for the module
-    target_include_directories(${NAME} PUBLIC ${NODEJS_INCLUDE_DIRS})
-
-    # Add link flags to the module
-    target_link_libraries(${NAME} ${NODEJS_LIBRARIES})
-
-    # Set required properties for the module to build properly
-    # Correct naming, symbol visiblity and C++ standard
-    set_target_properties(${NAME} PROPERTIES
-        OUTPUT_NAME ${NAME}
-        PREFIX ""
-        SUFFIX ".node"
-        MACOSX_RPATH ON
-        C_VISIBILITY_PRESET hidden
-        CXX_VISIBILITY_PRESET hidden
-        POSITION_INDEPENDENT_CODE TRUE
-        CMAKE_CXX_STANDARD_REQUIRED TRUE
-        CXX_STANDARD 11
-        LINK_FLAGS "${NODEJS_LINK_FLAGS}"
-    )
-
-    # Make sure we're buiilding in a build specific output directory
-    # Only necessary on single-target generators (Make, Ninja)
-    # Multi-target generators do this automatically
-    # This (luckily) mirrors node-gyp conventions
-    if(NOT CMAKE_CONFIGURATION_TYPES)
-        set_property(TARGET ${NAME} PROPERTY
-            LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BUILD_TYPE}
-        )
-    endif()
-endfunction()

cmake/nodejs/FindNodeJS.cmake

@@ -0,0 +1,587 @@
+# Copyright (c) 2015, Colin Taylor
+# Permission to use, copy, modify, and/or distribute this software for any 
+# purpose with or without fee is hereby granted, provided that the above 
+# copyright notice and this permission notice appear in all copies.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH 
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+# AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, 
+# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 
+# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 
+# OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 
+# PERFORMANCE OF THIS SOFTWARE.
+
+# FindNodeJS.cmake CMake module vendored from the node-cmake project (v1.2).
+
+# This script uses CMake 3.1+ features
+if(CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 3.1.0)
+    message(FATAL_ERROR "FindNodeJS.cmake uses CMake 3.1+ features")
+endif()
+
+# Force a build type to be set (ignored on config based generators)
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Debug CACHE STRING "Build type" FORCE)
+endif()
+
+# Capture module information
+set(NodeJS_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
+get_filename_component(NodeJS_MODULE_NAME ${NodeJS_MODULE_PATH} NAME)
+
+# Allow users to specify the installed location of the Node.js package
+set(NodeJS_ROOT_DIR "" CACHE PATH 
+    "The root directory of the node.js installed package")
+
+# Allow users to specify that downloaded sources should be used
+option(NodeJS_DOWNLOAD "Download the required source files" Off)
+
+# Allow users to force downloading of node packages
+option(NodeJS_FORCE_DOWNLOAD "Download the source files every time" Off)
+
+# Allow users to force archive extraction
+option(NodeJS_FORCE_EXTRACT "Extract the archive every time" Off)
+
+# Make libc++ the default when compiling with clang
+option(NodeJS_USE_CLANG_STDLIB "Use libc++ when compiling with clang" On)
+if(APPLE)
+    set(NodeJS_USE_CLANG_STDLIB On CACHE BOOL "" FORCE)
+endif()
+
+if(WIN32)
+    # Allow users to specify that the executable should be downloaded
+    option(NodeJS_DOWNLOAD_EXECUTABLE
+        "Download matching executable if available" Off
+    )
+endif()
+
+# Try to find the node.js executable
+# The node executable under linux may not be the correct program
+find_program(NodeJS_EXECUTABLE 
+    NAMES node
+    PATHS ${NodeJS_ROOT_DIR}
+    PATH_SUFFIXES nodejs node
+)
+set(NodeJS_VALIDATE_EXECUTABLE 1)
+if(NodeJS_EXECUTABLE)
+    execute_process(
+        COMMAND ${NodeJS_EXECUTABLE} --version
+        RESULT_VARIABLE NodeJS_VALIDATE_EXECUTABLE
+        OUTPUT_VARIABLE NodeJS_INSTALLED_VERSION
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    execute_process(
+        COMMAND ${NodeJS_EXECUTABLE} -p "process.platform"
+        OUTPUT_VARIABLE NodeJS_INSTALLED_PLATFORM
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    execute_process(
+        COMMAND ${NodeJS_EXECUTABLE} -p "process.arch"
+        OUTPUT_VARIABLE NodeJS_INSTALLED_ARCH
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+endif()
+
+# If node isn't the node.js binary, try the nodejs binary
+if(NOT NodeJS_VALIDATE_EXECUTABLE EQUAL 0)
+    find_program(NodeJS_EXECUTABLE
+        NAMES nodejs
+        PATHS ${NodeJS_ROOT_DIR}
+        PATH_SUFFIXES nodejs node
+    )
+    set(NodeJS_VALIDATE_EXECUTABLE 1)
+    if(NodeJS_EXECUTABLE)
+        execute_process(
+            COMMAND ${NodeJS_EXECUTABLE} --version
+            RESULT_VARIABLE NodeJS_VALIDATE_EXECUTABLE
+            OUTPUT_VARIABLE NodeJS_INSTALLED_VERSION
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+    endif()
+
+    if(NOT NodeJS_VALIDATE_EXECUTABLE EQUAL 0)
+        message(WARNING "Node.js executable could not be found. \
+        Set NodeJS_ROOT_DIR to the installed location of the executable or \
+        install Node.js to its default location.")
+    endif()
+endif()
+
+# Determine if a variant is set in the components
+list(APPEND NodeJS_OTHER_COMPONENTS
+    X64 IA32 ARM WIN32 LINUX DARWIN
+)
+set(NodeJS_COMPONENTS_CONTAINS_VARIANT False)
+foreach(NodeJS_COMPONENT ${NodeJS_FIND_COMPONENTS})
+    list(FIND NodeJS_OTHER_COMPONENTS ${NodeJS_COMPONENT} NodeJS_OTHER_INDEX)
+    if(NodeJS_OTHER_INDEX EQUAL -1)
+        set(NodeJS_COMPONENTS_CONTAINS_VARIANT True)
+        break()
+    endif()
+endforeach()
+
+# Get the targeted version of Node.js (or one of its derivatives)
+if(NOT NodeJS_VERSION)
+    if(NodeJS_FIND_VERSION)
+        set(NodeJS_VERSION ${NodeJS_FIND_VERSION})
+    elseif(NodeJS_INSTALLED_VERSION AND NOT NodeJS_COMPONENTS_CONTAINS_VARIANT)
+        string(SUBSTRING ${NodeJS_INSTALLED_VERSION} 1 -1 NodeJS_VERSION)
+    else()
+        message(FATAL_ERROR "Node.js version is not set. Set the VERSION \
+        property of the find_package command to the required version of the \
+        Node.js sources")
+    endif()
+endif()
+
+# Determine the target platform for the compiled module
+# Uses several mechanisms in order:
+# 
+# 1. CMake cache (allows overriding on the command line)
+# 2. Node architecture when binary is available
+# 3. CMake architecture
+# 
+set(NodeJS_PLATFORM "" CACHE STRING "Target node.js platform for module")
+if(NOT NodeJS_PLATFORM)
+    if(NodeJS_EXECUTABLE)
+        set(NodeJS_PLATFORM ${NodeJS_INSTALLED_PLATFORM})
+    elseif(WIN32)
+        set(NodeJS_PLATFORM "win32")
+    elseif(UNIX)
+        if(APPLE)
+            set(NodeJS_PLATFORM "darwin")
+        else()
+            set(NodeJS_PLATFORM "linux")
+        endif()
+    else()
+        message(FATAL_ERROR "Node.js platform is not set. Add the platform \
+        to the find_package components section or set NodeJS_PLATFORM in the \
+        cache.")
+    endif()
+endif()
+
+# Convenience variables for the platform type
+if(NodeJS_PLATFORM STREQUAL "win32")
+    set(NodeJS_PLATFORM_WIN32 True)
+    set(NodeJS_PLATFORM_LINUX False)
+    set(NodeJS_PLATFORM_DARWIN False)
+elseif(NodeJS_PLATFORM STREQUAL "linux")
+    set(NodeJS_PLATFORM_WIN32 False)
+    set(NodeJS_PLATFORM_LINUX True)
+    set(NodeJS_PLATFORM_DARWIN False)
+elseif(NodeJS_PLATFORM STREQUAL "darwin")
+    set(NodeJS_PLATFORM_WIN32 False)
+    set(NodeJS_PLATFORM_LINUX False)
+    set(NodeJS_PLATFORM_DARWIN True)
+endif()
+
+# Determine the target architecture for the compiled module
+# Uses several mechanisms in order:
+# 
+# 1. CMake cache (allows overriding on the command line)
+# 2. Node architecture when binary is available
+# 3. Compiler architecture under MSVC
+# 
+set(NodeJS_ARCH "" CACHE STRING "Target node.js architecture for module")
+if(NOT NodeJS_ARCH)
+    if(NodeJS_EXECUTABLE)
+        set(NodeJS_ARCH ${NodeJS_INSTALLED_ARCH})
+    elseif(MSVC)
+        if(CMAKE_CL_64)
+            set(NodeJS_ARCH "x64")
+        else()
+            set(NodeJS_ARCH "ia32")
+        endif()
+    else()
+        message(FATAL_ERROR "Node.js architecture is not set. Add the \
+        architecture to the find_package components section or set NodeJS_ARCH \
+        in the cache.")
+    endif()
+endif()
+
+# Convenience variables for the architecture
+if(NodeJS_ARCH STREQUAL "x64")
+    set(NodeJS_ARCH_X64 True)
+    set(NodeJS_ARCH_IA32 False)
+    set(NodeJS_ARCH_ARM False)
+elseif(NodeJS_ARCH STREQUAL "ia32")
+    set(NodeJS_ARCH_X64 False)
+    set(NodeJS_ARCH_IA32 True)
+    set(NodeJS_ARCH_ARM False)
+elseif(NodeJS_ARCH STREQUAL "arm")
+    set(NodeJS_ARCH_X64 False)
+    set(NodeJS_ARCH_IA32 False)
+    set(NodeJS_ARCH_ARM True)
+endif()
+
+# Include helper functions
+include(util/NodeJSUtil)
+
+# Default variant name
+# Used by the installed header comparison below
+set(NodeJS_DEFAULT_VARIANT_NAME "node.js")
+
+# Variables for Node.js artifacts across variants
+# Specify all of these variables for each new variant
+set(NodeJS_VARIANT_NAME "")       # The printable name of the variant
+set(NodeJS_VARIANT_BASE "")       # A file name safe version of the variant
+set(NodeJS_URL "")                # The URL for the artifacts
+set(NodeJS_SOURCE_PATH "")        # The URL path of the source archive
+set(NodeJS_CHECKSUM_PATH "")      # The URL path of the checksum file
+set(NodeJS_CHECKSUM_TYPE "")      # The checksum type (algorithm)
+set(NodeJS_WIN32_LIBRARY_PATH "") # The URL path of the windows library
+set(NodeJS_WIN32_BINARY_PATH "")  # The URL path of the windows executable
+set(NodeJS_WIN32_LIBRARY_NAME "") # The name of the windows library
+set(NodeJS_WIN32_BINARY_NAME "")  # The name of the windows executable
+
+set(NodeJS_DEFAULT_INCLUDE True)  # Enable default include behavior
+set(NodeJS_DEFAULT_LIBS True)     # Include the default libraries
+set(NodeJS_HAS_WIN32_PREFIX True) # Does the variant use library prefixes
+set(NodeJS_HAS_WIN32_BINARY True) # Does the variant have win32 executables
+set(NodeJS_HAS_OPENSSL True)      # Does the variant include openssl headers
+set(NodeJS_HEADER_VERSION 0.12.7) # Version after header-only archives start
+set(NodeJS_SHA256_VERSION 0.7.0)  # Version after sha256 checksums start
+set(NodeJS_PREFIX_VERSION 0.12.7) # Version after windows prefixing starts
+set(NodeJS_CXX11R_VERSION 0.12.7) # Version after c++11 is required
+set(NodeJS_SOURCE_INCLUDE True)   # Use the include paths from a source archive
+set(NodeJS_HEADER_INCLUDE False)  # Use the include paths from a header archive
+set(NodeJS_INCLUDE_PATHS "")      # Set of header dirs inside the source archive
+set(NodeJS_LIBRARIES "")          # The set of libraries to link with addon
+set(NodeJS_WIN32_DELAYLOAD "")    # Set of executables to delayload on windows
+
+# NodeJS variants
+# Selects download target based on configured component
+# Include NodeJS last to provide default configurations when omitted
+file(
+    GLOB NodeJS_SUPPORTED_VARIANTS
+    RELATIVE ${CMAKE_CURRENT_LIST_DIR}/variants
+    ${CMAKE_CURRENT_LIST_DIR}/variants/*
+)
+foreach(NodeJS_SUPPORTED_VARIANT ${NodeJS_SUPPORTED_VARIANTS})
+    get_filename_component(NodeJS_SUPPORTED_VARIANT_NAME
+        ${NodeJS_SUPPORTED_VARIANT} NAME_WE
+    )
+    if(NOT NodeJS_SUPPORTED_VARIANT_NAME STREQUAL "NodeJS")
+        include(variants/${NodeJS_SUPPORTED_VARIANT_NAME})
+    endif()
+endforeach()
+include(variants/NodeJS)
+
+# Populate version variables, including version components
+set(NodeJS_VERSION_STRING "v${NodeJS_VERSION}")
+
+# Populate the remaining version variables
+string(REPLACE "." ";" NodeJS_VERSION_PARTS ${NodeJS_VERSION})
+list(GET NodeJS_VERSION_PARTS 0 NodeJS_VERSION_MAJOR)
+list(GET NodeJS_VERSION_PARTS 1 NodeJS_VERSION_MINOR)
+list(GET NodeJS_VERSION_PARTS 2 NodeJS_VERSION_PATCH)
+
+# If the version we're looking for is the version that is installed,
+# try finding the required headers. Don't do this under windows (where
+# headers are not part of the installed content), when the user has
+# specified that headers should be downloaded or when using a variant other
+# than the default
+if((NOT NodeJS_PLATFORM_WIN32) AND (NOT NodeJS_DOWNLOAD) AND
+    NodeJS_VARIANT_NAME STREQUAL NodeJS_DEFAULT_VARIANT_NAME AND
+    NodeJS_INSTALLED_VERSION STREQUAL NodeJS_VERSION_STRING AND
+    NodeJS_INSTALLED_PLATFORM STREQUAL NodeJS_PLATFORM AND
+    NodeJS_INSTALLED_ARCH STREQUAL NodeJS_ARCH)
+    # node.h is really generic and too easy for cmake to find the wrong
+    # file, so use the directory as a guard, and then just tack it on to
+    # the actual path
+    # 
+    # Specifically ran into this under OSX, where python contains a node.h
+    # that gets found instead
+    find_path(NodeJS_INCLUDE_PARENT node/node.h)
+    set(NodeJS_INCLUDE_DIRS ${NodeJS_INCLUDE_PARENT}/node)
+
+    # Under all systems that support this, there are no libraries required
+    # for linking (symbols are resolved via the main executable at runtime)
+    set(NodeJS_LIBRARIES "")
+
+# Otherwise, headers and required libraries must be downloaded to the project
+# to supplement what is installed
+else()
+    # Create a folder for downloaded artifacts
+    set(NodeJS_DOWNLOAD_PATH 
+        ${CMAKE_CURRENT_BINARY_DIR}/${NodeJS_VARIANT_BASE}
+    )
+    set(NodeJS_DOWNLOAD_PATH ${NodeJS_DOWNLOAD_PATH}-${NodeJS_VERSION_STRING})
+    file(MAKE_DIRECTORY ${NodeJS_DOWNLOAD_PATH})
+
+    # Download the checksum file for validating all other downloads
+    # Conveniently, if this doesn't download correctly, the setup fails
+    # due to checksum failures
+    set(NodeJS_CHECKSUM_FILE ${NodeJS_DOWNLOAD_PATH}/CHECKSUM)
+    nodejs_download(
+        ${NodeJS_URL}/${NodeJS_CHECKSUM_PATH}
+        ${NodeJS_CHECKSUM_FILE}
+        ${NodeJS_FORCE_DOWNLOAD}
+    )
+    file(READ ${NodeJS_CHECKSUM_FILE} NodeJS_CHECKSUM_DATA)
+
+    # Download and extract the main source archive
+    set(NodeJS_SOURCE_FILE ${NodeJS_DOWNLOAD_PATH}/headers.tar.gz)
+    nodejs_checksum(
+        ${NodeJS_CHECKSUM_DATA} ${NodeJS_SOURCE_PATH} NodeJS_SOURCE_CHECKSUM
+    )
+    nodejs_download(
+        ${NodeJS_URL}/${NodeJS_SOURCE_PATH}
+        ${NodeJS_SOURCE_FILE}
+        ${NodeJS_SOURCE_CHECKSUM}
+        ${NodeJS_CHECKSUM_TYPE}
+        ${NodeJS_FORCE_DOWNLOAD}
+    )
+    set(NodeJS_HEADER_PATH ${NodeJS_DOWNLOAD_PATH}/src)
+    nodejs_extract(
+        ${NodeJS_SOURCE_FILE}
+        ${NodeJS_HEADER_PATH}
+        ${NodeJS_FORCE_EXTRACT}
+    )
+
+    # Populate include directories from the extracted source archive
+    foreach(NodeJS_HEADER_BASE ${NodeJS_INCLUDE_PATHS})
+        set(NodeJS_INCLUDE_DIR ${NodeJS_HEADER_PATH}/${NodeJS_HEADER_BASE})
+        if(NOT EXISTS ${NodeJS_INCLUDE_DIR})
+            message(FATAL_ERROR "Include does not exist: ${NodeJS_INCLUDE_DIR}")
+        endif()
+        list(APPEND NodeJS_INCLUDE_DIRS ${NodeJS_INCLUDE_DIR})
+    endforeach()
+
+    # Download required library files when targeting windows
+    if(NodeJS_PLATFORM_WIN32)
+        # Download the windows library
+        set(NodeJS_WIN32_LIBRARY_FILE 
+            ${NodeJS_DOWNLOAD_PATH}/lib/${NodeJS_ARCH}
+        )
+        set(NodeJS_WIN32_LIBRARY_FILE 
+            ${NodeJS_WIN32_LIBRARY_FILE}/${NodeJS_WIN32_LIBRARY_NAME}
+        )
+        nodejs_checksum(
+            ${NodeJS_CHECKSUM_DATA} ${NodeJS_WIN32_LIBRARY_PATH} 
+            NodeJS_WIN32_LIBRARY_CHECKSUM
+        )
+        nodejs_download(
+            ${NodeJS_URL}/${NodeJS_WIN32_LIBRARY_PATH}
+            ${NodeJS_WIN32_LIBRARY_FILE}
+            ${NodeJS_WIN32_LIBRARY_CHECKSUM}
+            ${NodeJS_CHECKSUM_TYPE}
+            ${NodeJS_FORCE_DOWNLOAD}
+        )
+        list(APPEND NodeJS_LIBRARIES ${NodeJS_WIN32_LIBRARY_FILE})
+
+        # If provided, download the windows executable
+        if(NodeJS_WIN32_BINARY_PATH AND 
+            NodeJS_DOWNLOAD_EXECUTABLE)
+            set(NodeJS_WIN32_BINARY_FILE 
+                ${NodeJS_DOWNLOAD_PATH}/lib/${NodeJS_ARCH}
+            )
+            set(NodeJS_WIN32_BINARY_FILE 
+                ${NodeJS_WIN32_BINARY_FILE}/${NodeJS_WIN32_BINARY_NAME}
+            )
+            nodejs_checksum(
+                ${NodeJS_CHECKSUM_DATA} ${NodeJS_WIN32_BINARY_PATH} 
+                NodeJS_WIN32_BINARY_CHECKSUM
+            )
+            nodejs_download(
+                ${NodeJS_URL}/${NodeJS_WIN32_BINARY_PATH}
+                ${NodeJS_WIN32_BINARY_FILE}
+                ${NodeJS_WIN32_BINARY_CHECKSUM}
+                ${NodeJS_CHECKSUM_TYPE}
+                ${NodeJS_FORCE_DOWNLOAD}
+            )
+        endif()
+    endif()
+endif()
+
+# Support windows delay loading
+if(NodeJS_PLATFORM_WIN32)
+    list(APPEND NodeJS_LINK_FLAGS /IGNORE:4199)
+    set(NodeJS_WIN32_DELAYLOAD_CONDITION "")
+    foreach(NodeJS_WIN32_DELAYLOAD_BINARY ${NodeJS_WIN32_DELAYLOAD})
+        list(APPEND NodeJS_LINK_FLAGS
+            /DELAYLOAD:${NodeJS_WIN32_DELAYLOAD_BINARY}
+        )
+        list(APPEND NodeJS_WIN32_DELAYLOAD_CONDITION
+            "_stricmp(info->szDll, \"${NodeJS_WIN32_DELAYLOAD_BINARY}\") != 0"
+        )
+    endforeach()
+    string(REPLACE ";" " &&\n     " 
+        NodeJS_WIN32_DELAYLOAD_CONDITION
+        "${NodeJS_WIN32_DELAYLOAD_CONDITION}"
+    )
+    configure_file(
+        ${NodeJS_MODULE_PATH}/src/win_delay_load_hook.c
+        ${CMAKE_CURRENT_BINARY_DIR}/win_delay_load_hook.c @ONLY
+    )
+    list(APPEND NodeJS_ADDITIONAL_SOURCES
+        ${CMAKE_CURRENT_BINARY_DIR}/win_delay_load_hook.c
+    )
+endif()
+
+# Allow undefined symbols on OSX
+if(NodeJS_PLATFORM_DARWIN)
+    list(APPEND NodeJS_LINK_FLAGS "-undefined dynamic_lookup")
+endif()
+
+# Use libc++ when clang is the compiler by default
+if(NodeJS_USE_CLANG_STDLIB AND CMAKE_CXX_COMPILER_ID MATCHES ".*Clang.*")
+    list(APPEND NodeJS_COMPILE_OPTIONS -stdlib=libc++)
+endif()
+
+# Require c++11 support after a specific point, but only if the user hasn't
+# specified an override
+if(NOT NodeJS_CXX_STANDARD) 
+    if(NodeJS_VERSION VERSION_GREATER NodeJS_CXX11R_VERSION)
+        set(NodeJS_CXX_STANDARD 11)
+    else()
+        set(NodeJS_CXX_STANDARD 98)
+    endif()
+endif()
+
+# Set required definitions
+list(APPEND NodeJS_DEFINITIONS BUILDING_NODE_EXTENSION)
+if(NodeJS_PLATFORM_DARWIN)
+    list(APPEND NodeJS_DEFINITIONS _DARWIN_USE_64_BIT_INODE=1)
+endif()
+if(NOT NodeJS_PLATFORM_WIN32)
+    list(APPEND NodeJS_DEFINITIONS
+        _LARGEFILE_SOURCE
+        _FILE_OFFSET_BITS=64
+    )
+endif()
+
+function(add_nodejs_module NAME)
+    # Build a shared library for the module
+    add_library(${NAME} SHARED ${ARGN} ${NodeJS_ADDITIONAL_SOURCES})
+
+    # Include required headers
+    # Find and include Nan as well (always available as its a 
+    # dependency of this module)
+    nodejs_find_module_fallback(nan ${CMAKE_CURRENT_SOURCE_DIR} NAN_PATH)
+    target_include_directories(${NAME} 
+        PUBLIC ${NodeJS_INCLUDE_DIRS}
+        PUBLIC ${NAN_PATH}
+    )
+
+    # Set module properties
+    # This ensures proper naming of the module library across all platforms
+    get_target_property(COMPILE_OPTIONS ${NAME} COMPILE_OPTIONS)
+    if(NOT COMPILE_OPTIONS)
+        set(COMPILE_OPTIONS "")
+    endif()
+    set(COMPILE_OPTIONS ${COMPILE_OPTIONS} ${NodeJS_COMPILE_OPTIONS})
+    get_target_property(LINK_FLAGS ${NAME} LINK_FLAGS)
+    if(NOT LINK_FLAGS)
+        set(LINK_FLAGS "")
+    endif()
+    foreach(NodeJS_LINK_FLAG ${NodeJS_LINK_FLAGS})
+        set(LINK_FLAGS "${LINK_FLAGS} ${NodeJS_LINK_FLAG}")
+    endforeach()
+    set_target_properties(${NAME} PROPERTIES
+        PREFIX ""
+        SUFFIX ".node"
+        MACOSX_RPATH ON
+        POSITION_INDEPENDENT_CODE TRUE
+        COMPILE_OPTIONS "${COMPILE_OPTIONS}"
+        LINK_FLAGS "${LINK_FLAGS}"
+        CXX_STANDARD_REQUIRED TRUE
+        CXX_STANDARD ${NodeJS_CXX_STANDARD}
+    )
+
+    # Output the module in a per build type directory
+    # This makes builds consistent with visual studio and other generators
+    # that build by configuration
+    if(NOT CMAKE_CONFIGURATION_TYPES)
+        set_property(TARGET ${NAME} PROPERTY LIBRARY_OUTPUT_DIRECTORY
+            ${CMAKE_BUILD_TYPE}
+        )
+    endif()
+
+    # Set any required complier flags
+    # Mostly used under windows
+    target_compile_definitions(${NAME} PRIVATE ${NodeJS_DEFINITIONS})
+
+    # Link against required NodeJS libraries
+    target_link_libraries(${NAME} ${NodeJS_LIBRARIES})
+endfunction()
+
+# Write out the configuration for node scripts
+configure_file(
+    ${NodeJS_MODULE_PATH}/build.json.in
+    ${CMAKE_CURRENT_BINARY_DIR}/build.json @ONLY
+)
+
+# Make sure we haven't violated the version-to-standard mapping
+if(NodeJS_VERSION VERSION_GREATER NodeJS_CXX11R_VERSION AND
+    NodeJS_CXX_STANDARD EQUAL 98)
+    message(FATAL_ERROR "${NodeJS_VARIANT_NAME} ${NodeJS_VERSION} \
+    requires C++11 or newer to build")
+endif()
+
+# This is a find_package file, handle the standard invocation
+include(FindPackageHandleStandardArgs)
+set(NodeJS_TARGET "${NodeJS_VARIANT_NAME} ${NodeJS_PLATFORM}/${NodeJS_ARCH}")
+find_package_handle_standard_args(NodeJS
+    FOUND_VAR NodeJS_FOUND
+    REQUIRED_VARS NodeJS_TARGET NodeJS_INCLUDE_DIRS
+    VERSION_VAR NodeJS_VERSION
+)
+
+# Mark variables that users shouldn't modify
+mark_as_advanced(
+    NodeJS_VALIDATE_EXECUTABLE
+    NodeJS_OTHER_COMPONENTS
+    NodeJS_COMPONENTS_CONTAINS_VARIANT
+    NodeJS_COMPONENT
+    NodeJS_OTHER_INDEX
+    NodeJS_VERSION_STRING
+    NodeJS_VERSION_MAJOR
+    NodeJS_VERSION_MINOR
+    NodeJS_VERSION_PATCH
+    NodeJS_VERSION_TWEAK
+    NodeJS_PLATFORM
+    NodeJS_PLATFORM_WIN32
+    NodeJS_PLATFORM_LINUX
+    NodeJS_PLATFORM_DARWIN
+    NodeJS_ARCH
+    NodeJS_ARCH_X64
+    NodeJS_ARCH_IA32
+    NodeJS_ARCH_ARM
+    NodeJS_DEFAULT_VARIANT_NAME
+    NodeJS_VARIANT_BASE
+    NodeJS_VARIANT_NAME
+    NodeJS_URL
+    NodeJS_SOURCE_PATH
+    NodeJS_CHECKSUM_PATH
+    NodeJS_CHECKSUM_TYPE
+    NodeJS_WIN32_LIBRARY_PATH
+    NodeJS_WIN32_BINARY_PATH
+    NodeJS_WIN32_LIBRARY_NAME
+    NodeJS_WIN32_BINARY_NAME
+    NodeJS_DEFAULT_INCLUDE
+    NodeJS_DEFAULT_LIBS
+    NodeJS_HAS_WIN32_BINARY
+    NodeJS_HEADER_VERSION
+    NodeJS_SHA256_VERISON
+    NodeJS_PREFIX_VERSION
+    NodeJS_SOURCE_INCLUDE
+    NodeJS_HEADER_INCLUDE
+    NodeJS_INCLUDE_PATHS
+    NodeJS_WIN32_DELAYLOAD
+    NodeJS_DOWNLOAD_PATH
+    NodeJS_CHECKSUM_FILE
+    NodeJS_CHECKSUM_DATA
+    NodeJS_SOURCE_FILE
+    NodeJS_SOURCE_CHECKSUM
+    NodeJS_HEADER_PATH
+    NodeJS_HEADER_BASE
+    NodeJS_INCLUDE_DIR
+    NodeJS_WIN32_LIBRARY_FILE
+    NodeJS_WIN32_LIBRARY_CHECKSUM
+    NodeJS_WIN32_BINARY_FILE
+    NodeJS_WIN32_BINARY_CHECKSUM
+    NodeJS_NAN_PATH
+    NodeJS_LINK_FLAGS
+    NodeJS_COMPILE_OPTIONS
+    NodeJS_ADDITIONAL_SOURCES
+    NodeJS_WIN32_DELAYLOAD_CONDITION
+    NodeJS_WIN32_DELAYLOAD_BINARY
+    NodeJS_TARGET
+)

cmake/nodejs/build.json.in

@@ -0,0 +1,10 @@
+{
+  "build_type": "@CMAKE_BUILD_TYPE@",
+  "generator": "@CMAKE_GENERATOR@",
+  "toolset": "@CMAKE_GENERATOR_TOOLSET@",
+  "platform": "@CMAKE_GENERATOR_PLATFORM@",
+  "variant": "@NodeJS_VARIANT_BASE@",
+  "version": "@NodeJS_VERSION@",
+  "download": "@NodeJS_DOWNLOAD@",
+  "standard": "@NodeJS_CXX_STANDARD@"
+}

cmake/nodejs/util/Github.cmake

@@ -0,0 +1,28 @@
+set(GITHUB_API_TOKEN $ENV{GITHUB_API_TOKEN})
+
+set(GITHUB_AUTH "")
+if(GITHUB_API_TOKEN)
+    set(GITHUB_AUTH "?access_token=${GITHUB_API_TOKEN}")
+endif()
+
+set(GITHUB_API_URL "https://api.github.com")
+
+function(github_get_rate_limit VAR)
+    set(RATE_LIMIT_FILE ${CMAKE_CURRENT_BINARY_DIR}/GITHUBRATE)
+    set(RATE_LIMIT_URL ${GITHUB_API_URL}/rate_limit${GITHUB_AUTH})
+    nodejs_download(
+        ${RATE_LIMIT_URL}
+        ${RATE_LIMIT_FILE}
+        ON
+    )
+    file(READ ${RATE_LIMIT_FILE} RATE_LIMIT_DATA)
+    string(REGEX MATCH "\"remaining\": ([0-9]+),"
+        RATE_LIMIT_MATCH ${RATE_LIMIT_DATA})
+    set(${VAR} ${CMAKE_MATCH_1} PARENT_SCOPE)
+endfunction()
+
+mark_as_advanced(
+    GITHUB_AUTH
+    GITHUB_API_TOKEN
+    GITHUB_API_URL
+)

cmake/nodejs/util/NodeJSUtil.cmake

@@ -0,0 +1,166 @@
+function(nodejs_check_file FILE)
+    set(MESSAGE "File ${FILE} does not exist or is empty")
+    if(ARGC GREATER 1)
+        set(MESSAGE ${ARGV1})
+    endif()
+
+    # Make sure the file has contents
+    file(READ ${FILE} FILE_CONTENT LIMIT 1 HEX)
+    if(NOT FILE_CONTENT)
+        file(REMOVE ${FILE})
+        message(FATAL_ERROR ${MESSAGE})
+    endif()
+endfunction()
+
+function(nodejs_download URL FILE)
+    # Function optionally takes a checksum and a checksum type, and
+    # a force value
+    # Either can be specified without the other, but checksum must come first
+    if(ARGC GREATER 2)
+        set(CHECKSUM ${ARGV2})
+        if(CHECKSUM STREQUAL "On" OR CHECKSUM STREQUAL "ON" OR
+            CHECKSUM STREQUAL "True" OR CHECKSUM STREQUAL "TRUE" OR
+            CHECKSUM STREQUAL "Off" OR CHECKSUM STREQUAL "OFF" OR
+            CHECKSUM STREQUAL "False" OR CHECKSUM STREQUAL "FALSE")
+            set(FORCE ${CHECKSUM})
+            unset(CHECKSUM)
+        elseif(ARGC GREATER 3)
+            set(TYPE ${ARGV3})
+        else()
+            message(FATAL_ERROR "Checksum type must be specified")
+        endif()
+    elseif(ARGC GREATER 4)
+        set(CHECKSUM ${ARGV2})
+        set(TYPE ${ARGV3})
+        set(FORCE ${ARGV4})
+    endif()
+
+    # If the file exists, no need to download it again unless its being forced
+    if(NOT FORCE AND EXISTS ${FILE})
+        return()
+    endif()
+
+    # Download the file
+    message(STATUS "Downloading: ${URL}")
+    file(DOWNLOAD 
+        ${URL}
+        ${FILE}
+        SHOW_PROGRESS
+    )
+
+    # Make sure the file has contents
+    nodejs_check_file(${FILE} "Unable to download ${URL}")
+
+    # If a checksum is provided, validate the downloaded file
+    if(CHECKSUM)
+        message(STATUS "Validating: ${FILE}")
+        file(${TYPE} ${FILE} DOWNLOAD_CHECKSUM)
+        message(STATUS "Checksum: ${CHECKSUM}")
+        message(STATUS "Download: ${DOWNLOAD_CHECKSUM}")
+        if(NOT CHECKSUM STREQUAL DOWNLOAD_CHECKSUM)
+            file(REMOVE ${FILE})
+            message(FATAL_ERROR "Validation failure: ${FILE}")
+        endif()
+    endif()
+endfunction()
+
+function(nodejs_checksum DATA FILE VAR)
+    string(REGEX MATCH "([A-Fa-f0-9]+)[\t ]+${FILE}" CHECKSUM_MATCH ${DATA})
+    if(CMAKE_MATCH_1)
+        set(${VAR} ${CMAKE_MATCH_1} PARENT_SCOPE)
+    else()
+        message(FATAL_ERROR "Unable to extract file checksum")
+    endif()
+endfunction()
+
+function(nodejs_extract FILE DIR)
+    # Function optionally takes a force value
+    if(ARGC GREATER 2)
+        set(FORCE ${ARGV2})
+    endif()
+
+    # If the archvie has been extracted, no need to extract again unless it
+    # is being forced
+    if(NOT FORCE AND EXISTS ${DIR})
+        return()
+    endif()
+
+    # Make a temporary directory for extracting the output
+    set(EXTRACT_DIR ${CMAKE_CURRENT_BINARY_DIR}/extract)
+    if(EXISTS ${EXTRACT_DIR})
+        file(REMOVE_RECURSE ${EXTRACT_DIR})
+    endif()
+    file(MAKE_DIRECTORY ${EXTRACT_DIR})
+
+    # Extract the archive
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} -E tar xfz ${FILE}
+        WORKING_DIRECTORY ${EXTRACT_DIR}
+    )
+    
+    # If only one element is extracted, the archive contained a nested
+    # folder; use the inner folder as the extracted folder
+    file(GLOB EXTRACT_CHILDREN ${EXTRACT_DIR}/*)
+    list(LENGTH EXTRACT_CHILDREN NUM_CHILDREN)
+    set(TARGET_DIR ${EXTRACT_DIR})
+    if(NUM_CHILDREN EQUAL 1)
+        list(GET EXTRACT_CHILDREN 0 TARGET_DIR)
+    endif()
+
+    # Move the folder to the target path
+    if(EXISTS ${DIR})
+        file(REMOVE_RECURSE ${DIR})
+    endif()
+    file(RENAME ${TARGET_DIR} ${DIR})
+    
+    # Make sure to clean up the extraction folder when the inner folder
+    # is used
+    file(REMOVE_RECURSE ${EXTRACT_DIR})
+endfunction()
+
+function(nodejs_find_module NAME BASE PATH)
+    # Find a node module using the same search path that require uses
+    # without needing a node binary
+    set(ROOT ${BASE})
+    set(DRIVE "^[A-Za-z]?:?/$")
+
+    # Walk up the directory tree until at the root
+    while(NOT ROOT MATCHES ${DRIVE} AND NOT 
+        EXISTS ${ROOT}/node_modules/${NAME})
+        get_filename_component(ROOT ${ROOT} DIRECTORY)
+    endwhile()
+
+    # Operate like the CMake find_* functions, returning NOTFOUND if the
+    # module can't be found
+    if(ROOT MATCHES ${DRIVE})
+        set(${PATH} ${NAME}-NOTFOUND PARENT_SCOPE)
+    else()
+        set(${PATH} ${ROOT}/node_modules/${NAME} PARENT_SCOPE)
+    endif()
+endfunction()
+
+macro(nodejs_find_module_fallback NAME BASE PATH)
+    # Look in the provided path first
+    # If the module isn't found, try searching from the module
+    nodejs_find_module(${NAME} ${BASE} ${PATH})
+    if(NOT ${PATH})
+        nodejs_find_module(${NAME} ${NodeJS_MODULE_PATH} ${PATH})
+    endif()
+endmacro()
+
+function(nodejs_get_version URL VAR)
+    set(NWJS_LATEST_RELEASE_URL 
+        "${NWJS_URL_BASE}/latest/${NodeJS_CHECKSUM_PATH}")
+    set(VERSION_FILE ${CMAKE_CURRENT_BINARY_DIR}/VERSION)
+    nodejs_download(
+        ${URL}
+        ${VERSION_FILE}
+        ON
+    )
+    nodejs_check_file(${VERSION_FILE})
+    file(READ ${VERSION_FILE} VERSION_DATA)
+    string(REGEX MATCH "v([0-9]+\.[0-9]+\.[0-9]+)" 
+        VERSION_MATCH ${VERSION_DATA}
+    )
+    set(${VAR} ${CMAKE_MATCH_1} PARENT_SCOPE)
+endfunction()

cmake/nodejs/variants/Electron.cmake

@@ -0,0 +1,81 @@
+set(ELECTRON_VARIANT_BASE "electron")
+set(ELECTRON_WIN32_BINARY_NAME "${ELECTRON_VARIANT_BASE}.exe")
+list(APPEND NodeJS_WIN32_DELAYLOAD ${ELECTRON_WIN32_BINARY_NAME})
+
+if(NodeJS_FIND_REQUIRED_ELECTRON OR 
+   NodeJS_VARIANT STREQUAL ${ELECTRON_VARIANT_BASE})
+    if(NodeJS_VERSION STREQUAL "latest")
+        include(util/Github)
+        github_get_rate_limit(GITHUB_RATE_LIMIT)
+
+        # Handle determining the latest release
+        # Very complicated, due to electron not following the "latest"
+        # convention of other variants
+        set(ELECTRON_LATEST_RELEASE_FILE ${CMAKE_CURRENT_BINARY_DIR}/ELECTRON)
+        set(ELECTRON_LATEST_RELEASE_URL
+            ${GITHUB_API_URL}/repos/atom/electron/releases/latest${GITHUB_AUTH}
+        )
+        if(GITHUB_RATE_LIMIT GREATER 0)
+            nodejs_download(
+                ${ELECTRON_LATEST_RELEASE_URL}
+                ${ELECTRON_LATEST_RELEASE_FILE}
+                ON
+            )
+        endif()
+        nodejs_check_file(
+            ${ELECTRON_LATEST_RELEASE_FILE} 
+            "Releases file could not be downloaded, likely \
+            because github rate limit was exceeded. Wait until the limit \
+            passes or set GITHUB_API_TOKEN in your environment to a valid \
+            github developer token."
+        )
+        file(READ ${ELECTRON_LATEST_RELEASE_FILE} ELECTRON_LATEST_RELEASE_DATA)
+            string(REGEX MATCH "\"tag_name\"\: \"v([0-9]+\.[0-9]+\.[0-9]+)\"" 
+        ELECTRON_LATEST_RELEASE_MATCH ${ELECTRON_LATEST_RELEASE_DATA})
+        set(NodeJS_VERSION ${CMAKE_MATCH_1})
+    endif()
+
+    set(NodeJS_VARIANT_NAME "Electron.js")
+
+    # SHASUMS of any kind is inaccessible prior to 0.16.0
+    if(NodeJS_VERSION VERSION_LESS 0.16.0)
+        message(FATAL_ERROR "Electron is only supported for versions >= 0.16.0")
+    endif()
+    
+    # Electron switched to IOJS after 0.25.0
+    # Probably needs to be bounded on the upper side if/when they switch
+    # back to node mainline due to iojs-node merge
+    set(NodeJS_VARIANT_BASE "node")
+    if(NodeJS_VERSION VERSION_GREATER 0.25.0)
+        set(NodeJS_VARIANT_BASE "iojs")
+    endif()
+
+    # Url is hard to get, because it will immediately resolve to a CDN
+    # Extracted from the electron website
+    set(NodeJS_URL 
+        "https://atom.io/download/atom-shell/v${NodeJS_VERSION}"
+    )
+
+    # Headers become available for IOJS base ONLY!
+    # Variant base switch above handles this
+    set(NodeJS_HEADER_VERSION 0.30.1)
+
+    # Header only archive uses source style paths
+    set(NodeJS_DEFAULT_INCLUDE False)
+
+    # Hard to determine, but versions seem to start at 16, and SHA256 is
+    # available
+    set(NodeJS_SHA256_VERSION 0.15.9)
+
+    # C++11 and Prefixing start after the IOJS switch
+    # Will carry forward after node mainline so no need for upper bound (whew)
+    set(NodeJS_PREFIX_VERSION 0.25.0)
+    set(NodeJS_CXX11R_VERSION 0.25.0)
+
+    # The executable is not provided on the CDN
+    # In theory, I could support a BINARY_URL to get this from github
+    set(NodeJS_HAS_WIN32_BINARY False)
+
+    # OpenSSL isn't included in the headers
+    set(NodeJS_HAS_OPENSSL False)
+endif()

cmake/nodejs/variants/IOJS.cmake

@@ -0,0 +1,25 @@
+set(IOJS_URL_BASE "https://iojs.org/dist")
+set(IOJS_VARIANT_BASE "iojs")
+set(IOJS_WIN32_BINARY_NAME  "${IOJS_VARIANT_BASE}.exe")
+list(APPEND NodeJS_WIN32_DELAYLOAD ${IOJS_WIN32_BINARY_NAME})
+
+if(NodeJS_FIND_REQUIRED_IOJS OR NodeJS_VARIANT STREQUAL ${IOJS_VARIANT_BASE})
+    if(NodeJS_VERSION STREQUAL "latest")
+        set(IOJS_LATEST_RELEASE_URL 
+            "${IOJS_URL_BASE}/latest/SHASUMS256.txt")
+        nodejs_get_version(${IOJS_LATEST_RELEASE_URL} NodeJS_VERSION)
+    endif()
+
+    set(NodeJS_VARIANT_NAME "io.js")
+    set(NodeJS_VARIANT_BASE ${IOJS_VARIANT_BASE})
+    set(NodeJS_URL "${IOJS_URL_BASE}/v${NodeJS_VERSION}")
+    set(NodeJS_HEADER_VERSION 2.3.1)
+    set(NodeJS_WIN32_BINARY_NAME "${IOJS_WIN32_BINARY_NAME}")
+endif()
+
+mark_as_advanced(
+    IOJS_URL_BASE
+    IOJS_VARIANT_BASE
+    IOJS_WIN32_BINARY_NAME
+    IOJS_LATEST_RELEASE_URL
+)

cmake/nodejs/variants/NWJS.cmake

@@ -0,0 +1,30 @@
+set(NWJS_URL_BASE "http://dl.nwjs.io")
+set(NWJS_VARIANT_BASE "nw")
+set(NWJS_WIN32_BINARY_NAME  "${NWJS_VARIANT_BASE}.exe")
+list(APPEND NodeJS_WIN32_DELAYLOAD ${NWJS_WIN32_BINARY_NAME})
+
+if(NodeJS_FIND_REQUIRED_NWJS OR NodeJS_VARIANT STREQUAL ${NWJS_VARIANT_BASE})
+    set(NodeJS_CHECKSUM_PATH "MD5SUMS")
+    set(NodeJS_CHECKSUM_TYPE "MD5")
+    
+    if(NodeJS_VERSION STREQUAL "latest")
+        set(NWJS_LATEST_RELEASE_URL 
+            "${NWJS_URL_BASE}/latest/${NodeJS_CHECKSUM_PATH}")
+        nodejs_get_version(${NWJS_LATEST_RELEASE_URL} NodeJS_VERSION)
+    endif()
+
+    set(NodeJS_VARIANT_NAME "nw.js")
+    set(NodeJS_VARIANT_BASE ${NWJS_VARIANT_BASE})
+    set(NodeJS_URL "${NWJS_URL_BASE}/v${NodeJS_VERSION}")
+    set(NodeJS_SOURCE_PATH "nw-headers-v${NodeJS_VERSION}.tar.gz")
+    set(NodeJS_DEFAULT_INCLUDE False)
+    set(NodeJS_HAS_WIN32_PREFIX False)
+    set(NodeJS_HAS_WIN32_BINARY False)
+endif()
+
+mark_as_advanced(
+    NWJS_URL_BASE
+    NWJS_VARIANT_BASE
+    NWJS_WIN32_BINARY_NAME
+    NWJS_LATEST_RELEASE_URL
+)

cmake/nodejs/variants/NodeJS.cmake

@@ -0,0 +1,131 @@
+set(NodeJS_URL_BASE http://nodejs.org/dist)
+set(NodeJS_DEFAULT_VARIANT_BASE "node")
+set(NodeJS_DEFAULT_WIN32_BINARY_NAME "${NodeJS_DEFAULT_VARIANT_BASE}.exe")
+list(APPEND NodeJS_WIN32_DELAYLOAD ${NodeJS_DEFAULT_WIN32_BINARY_NAME})
+
+if(NodeJS_VERSION STREQUAL "latest")
+    set(NodeJS_LATEST_RELEASE_URL 
+        "${NodeJS_URL_BASE}/latest/SHASUMS256.txt")
+    nodejs_get_version(${NodeJS_LATEST_RELEASE_URL} NodeJS_VERSION)
+endif()
+
+if(NOT NodeJS_VARIANT_NAME)
+    set(NodeJS_VARIANT_NAME ${NodeJS_DEFAULT_VARIANT_NAME})
+endif()
+if(NOT NodeJS_VARIANT_BASE)
+    set(NodeJS_VARIANT_BASE ${NodeJS_DEFAULT_VARIANT_BASE})
+endif()
+if(NOT NodeJS_URL)
+    set(NodeJS_URL "${NodeJS_URL_BASE}/v${NodeJS_VERSION}")
+endif()
+
+if(NOT NodeJS_SOURCE_PATH)
+    set(NodeJS_SOURCE_PATH "${NodeJS_VARIANT_BASE}-v${NodeJS_VERSION}")
+    # Use the headers archive when its available
+    if(NodeJS_VERSION VERSION_GREATER ${NodeJS_HEADER_VERSION})
+        set(NodeJS_SOURCE_PATH "${NodeJS_SOURCE_PATH}-headers")
+    endif()
+    set(NodeJS_SOURCE_PATH "${NodeJS_SOURCE_PATH}.tar.gz")
+endif()
+
+if(NodeJS_DEFAULT_INCLUDE AND 
+    NodeJS_VERSION VERSION_GREATER ${NodeJS_HEADER_VERSION})
+    set(NodeJS_SOURCE_INCLUDE False)
+    set(NodeJS_HEADER_INCLUDE True)
+endif()
+
+if(NodeJS_SOURCE_INCLUDE)
+    list(APPEND NodeJS_INCLUDE_PATHS
+        src
+        deps/uv/include
+        deps/v8/include
+        deps/zlib
+    )
+    # OpenSSL is an optional header
+    if(NodeJS_HAS_OPENSSL)
+        list(APPEND NodeJS_INCLUDE_PATHS
+            deps/openssl/openssl/include
+        )
+    endif()
+endif()
+if(NodeJS_HEADER_INCLUDE)
+    set(NodeJS_INCLUDE_PATHS include/node)
+endif()
+
+if(NOT NodeJS_CHECKSUM_TYPE)
+    # Use SHA256 when available
+    if(NodeJS_VERSION VERSION_GREATER ${NodeJS_SHA256_VERSION})
+        set(NodeJS_CHECKSUM_TYPE "SHA256")
+    else()
+        set(NodeJS_CHECKSUM_TYPE "SHA1")
+    endif()
+endif()
+
+if(NOT NodeJS_CHECKSUM_PATH)
+    set(NodeJS_CHECKSUM_PATH "SHASUMS")
+    if(NodeJS_CHECKSUM_TYPE STREQUAL "SHA256")
+        set(NodeJS_CHECKSUM_PATH "${NodeJS_CHECKSUM_PATH}256")
+    endif()
+    set(NodeJS_CHECKSUM_PATH "${NodeJS_CHECKSUM_PATH}.txt")
+endif()
+
+# Library and binary are based on variant base
+if(NOT NodeJS_WIN32_LIBRARY_NAME)
+    set(NodeJS_WIN32_LIBRARY_NAME ${NodeJS_VARIANT_BASE}.lib)
+endif()
+if(NOT NodeJS_WIN32_BINARY_NAME)
+    set(NodeJS_WIN32_BINARY_NAME ${NodeJS_VARIANT_BASE}.exe)
+endif()
+
+if(NOT NodeJS_WIN32_LIBRARY_PATH)
+    # The library location is prefixed after a specific version
+    if(NodeJS_HAS_WIN32_PREFIX AND 
+       NodeJS_VERSION VERSION_GREATER ${NodeJS_PREFIX_VERSION})
+        set(NodeJS_WIN32_LIBRARY_PATH "win-")
+        if(NodeJS_ARCH_IA32)
+            set(NodeJS_WIN32_LIBRARY_PATH "${NodeJS_WIN32_LIBRARY_PATH}x86/")
+        endif()
+    endif()
+    # 64-bit versions are prefixed
+    if(NodeJS_ARCH_X64)
+        set(NodeJS_WIN32_LIBRARY_PATH "${NodeJS_WIN32_LIBRARY_PATH}x64/")
+    endif()
+    set(NodeJS_WIN32_LIBRARY_PATH 
+        "${NodeJS_WIN32_LIBRARY_PATH}${NodeJS_WIN32_LIBRARY_NAME}"
+    )
+endif()
+
+if(NodeJS_HAS_WIN32_BINARY AND NOT NodeJS_WIN32_BINARY_PATH)
+    # The executable location is prefixed after a specific version
+    if(NodeJS_HAS_WIN32_PREFIX AND 
+       NodeJS_VERSION VERSION_GREATER ${NodeJS_PREFIX_VERSION})
+        set(NodeJS_WIN32_BINARY_PATH "win-")
+        if(NodeJS_ARCH_IA32)
+            set(NodeJS_WIN32_BINARY_PATH "${NodeJS_WIN32_BINARY_PATH}x86/")
+        endif()
+    endif()
+    # 64-bit versions are prefixed
+    if(NodeJS_ARCH_X64)
+        set(NodeJS_WIN32_BINARY_PATH "${NodeJS_WIN32_BINARY_PATH}x64/")
+    endif()
+    set(NodeJS_WIN32_BINARY_PATH 
+        "${NodeJS_WIN32_BINARY_PATH}${NodeJS_WIN32_BINARY_NAME}"
+    )
+endif()
+
+# Specify windows libraries
+# XXX: This may need to be version/variant specific in the future
+if(NodeJS_DEFAULT_LIBS AND NodeJS_PLATFORM_WIN32)
+    list(APPEND NodeJS_LIBRARIES
+        kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib
+        advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib
+        odbc32.lib DelayImp.lib
+    )
+endif()
+
+mark_as_advanced(
+    NodeJS_URL_BASE
+    NodeJS_DEFAULT_VARIANT_BASE
+    NodeJS_DEFAULT_WIN32_BINARY_NAME
+    NodeJS_LATEST_RELEASE_URL
+)

cucumber.js

@@ -3,5 +3,5 @@ module.exports = {
     verify: '--strict --tags ~@stress --tags ~@todo -f progress --require features/support --require features/step_definitions',
     todo: '--strict --tags @todo --require features/support --require features/step_definitions',
     all: '--strict --require features/support --require features/step_definitions',
-    mld: '--strict --tags ~@stress --tags ~@todo --tags ~@alternative --tags ~@matrix --tags ~@trip --require features/support --require features/step_definitions -f progress'
+    mld: '--strict --tags ~@stress --tags ~@todo --tags ~@match --tags ~@alternative --tags ~@matrix --tags ~@trip --tags ~@via --require features/support --require features/step_definitions -f progress'
 }

docs/profiles.md

@@ -36,7 +36,6 @@ use_turn_restrictions         | Boolean  | Are turn instructions followed?
 continue_straight_at_waypoint | Boolean  | Must the route continue straight on at a via point, or are U-turns allowed?
 max_speed_for_map_matching    | Float    | Maximum vehicle speed to be assumed in matching (in m/s)
 max_turn_weight               | Float    | Maximum turn penalty weight
-force_split_edges             | Boolean  | True value forces a split of forward and backward edges of extracted ways and guarantees that segment_function will be called for all segments
 
 ## way_function
 

docs/releasing.md

@@ -32,25 +32,21 @@ We may introduce forward-compatible changes: query parameters and response prope
 
 - The `master` branch is for the bleeding edge development
 - We create and maintain release branches `x.y` to control the release flow
-- We create the release branch once we create release branches once we want to release the first RC
-- RCs go in the release branch, commits needs to be cherry-picked from master
+- We create the release branch once we tagged the final version `x.y.0` version, RCs go on master
 - No minor or major version will be released without a code-equal release candidates
-- For quality assurance, release candidates need to be staged beforing tagging a final release
+- For quality assurance, release candidates will be run on the demo server for 24 hours before releaseing the version proper
 - Patch versions may be released without a release candidate
 - We may backport fixes to older versions and release them as patch versions
 
 ## Releasing a version
 
 1. Check out the appropriate release branch `x.y`
-2. Make sure `CHANGELOG.md` is up to date.
-3. Make sure the OSRM version in `CMakeLists.txt` is up to date
-4. Make sure the `package.json` is up to date.
-5. Make sure all tests are passing (e.g. Travis CI gives you a :thumbs_up:)
-6. Use an annotated tag to mark the release: `git tag vx.y.z -a` Body of the tag description should be the changelog entries.
-7. Use `npm run build-api-docs` to generate the API documentation.  Copy `build/docs/*` to `https://github.com/Project-OSRM/project-osrm.github.com` in the `docs/vN.N.N/api` directory
-8. Push tags and commits: `git push; git push --tags`
+2. Make sure all tests are passing (e.g. Travis CI gives you a :thumbs_up:)
+3. Make sure `CHANGELOG.md` is up to date.
+4. Make sure the OSRM version in `CMakeLists.txt` is up to date
+5. Use an annotated tag to mark the release: `git tag vx.y.z -a` Body of the tag description should be the changelog entries.
+6. Use `npm run build-api-docs` to generate the API documentation.  Copy `build/docs/*` to `https://github.com/Project-OSRM/project-osrm.github.com` in the `docs/vN.N.N/api` directory
+6. Push tags and commits: `git push; git push --tags`
+8. Proceede with the `node-osrm` release as [outlined in the repository](https://github.com/Project-OSRM/node-osrm/blob/master/docs/releasing.md).
 9. If not a release-candidate: Write a mailing-list post to osrm-talk@openstreetmap.org to announce the release
-10. Wait until the travis build has been completed and check if the node binaries were published by doing:
-    `rm -rf node_modules && npm install` locally.
-11. For final releases run `npm publish` or `npm publish --tag next` for release candidates.
 

features/raster/extract.feature

@@ -2,10 +2,10 @@
 Feature: osrm-extract with a profile containing raster source
     Scenario: osrm-extract on a valid profile
         Given the profile "rasterbot"
-        And the node locations
-            | node | lat        | lon      |
-            | a    | 0.1        | 0.1      |
-            | b    | 0.05       | 0.1      |
+        And the node map
+            """
+            a b
+            """
         And the ways
             | nodes |
             | ab    |
@@ -20,6 +20,4 @@ Feature: osrm-extract with a profile containing raster source
         And the data has been saved to disk
         When I run "osrm-extract {osm_file} -p {profile_file}"
         Then stdout should contain "source loader"
-        Then stdout should contain "slope: 0.0899"
-        Then stdout should contain "slope: -0.0899"
         And it should exit successfully

features/raster/weights.feature

@@ -50,9 +50,8 @@ Feature: Raster - weights
         And I route I should get
             | from | to | route    | speed   |
             | a    | b  | ab,ab    | 8 km/h  |
-            | b    | a  | ab,ab    | 22 km/h |
-            | a    | c  | ab,bc,bc | 12 km/h |
-            | b    | c  | bc,bc    | 22 km/h |
+            | a    | c  | ad,dc,dc | 15 km/h |
+            | b    | c  | bc,bc    | 8 km/h  |
             | a    | d  | ad,ad    | 15 km/h |
             | d    | c  | dc,dc    | 15 km/h |
             | d    | e  | de,de    | 10 km/h |

features/step_definitions/matching.js

@@ -175,7 +175,8 @@ module.exports = function () {
 
                     if (headers.has('matchings')) {
                         if (subMatchings.length != row.matchings.split(',').length) {
-                            return cb(new Error('*** table matchings and api response are not the same'));
+                            ok = false;
+                            cb(new Error('*** table matchings and api response are not the same'));
                         }
 
                         row.matchings.split(',').forEach((sub, si) => {

include/contractor/contractor.hpp

@@ -68,8 +68,9 @@ class Contractor
     void WriteCoreNodeMarker(std::vector<bool> &&is_core_node) const;
     void WriteNodeLevels(std::vector<float> &&node_levels) const;
     void ReadNodeLevels(std::vector<float> &contraction_order) const;
-    void WriteContractedGraph(unsigned number_of_edge_based_nodes,
-                              util::DeallocatingVector<QueryEdge> contracted_edge_list);
+    std::size_t
+    WriteContractedGraph(unsigned number_of_edge_based_nodes,
+                         const util::DeallocatingVector<QueryEdge> &contracted_edge_list);
     void FindComponents(unsigned max_edge_id,
                         const util::DeallocatingVector<extractor::EdgeBasedEdge> &edges,
                         std::vector<extractor::EdgeBasedNode> &nodes) const;

include/contractor/files.hpp

@@ -1,50 +0,0 @@
-#ifndef OSRM_CONTRACTOR_FILES_HPP
-#define OSRM_CONTRACTOR_FILES_HPP
-
-#include "contractor/query_graph.hpp"
-
-#include "util/serialization.hpp"
-
-#include "storage/io.hpp"
-
-namespace osrm
-{
-namespace contractor
-{
-namespace files
-{
-
-// reads .osrm.hsgr file
-template <typename QueryGraphT>
-inline void readGraph(const boost::filesystem::path &path, unsigned &checksum, QueryGraphT &graph)
-{
-    static_assert(std::is_same<QueryGraphView, QueryGraphT>::value ||
-                      std::is_same<QueryGraph, QueryGraphT>::value,
-                  "graph must be of type QueryGraph<>");
-
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    reader.ReadInto(checksum);
-    util::serialization::read(reader, graph);
-}
-
-// writes .osrm.hsgr file
-template <typename QueryGraphT>
-inline void
-writeGraph(const boost::filesystem::path &path, unsigned checksum, const QueryGraphT &graph)
-{
-    static_assert(std::is_same<QueryGraphView, QueryGraphT>::value ||
-                      std::is_same<QueryGraph, QueryGraphT>::value,
-                  "graph must be of type QueryGraph<>");
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    writer.WriteOne(checksum);
-    util::serialization::write(writer, graph);
-}
-}
-}
-}
-
-#endif

include/contractor/query_graph.hpp

@@ -1,25 +0,0 @@
-#ifndef OSRM_CONTRACTOR_QUERY_GRAPH_HPP
-#define OSRM_CONTRACTOR_QUERY_GRAPH_HPP
-
-#include "contractor/query_edge.hpp"
-
-#include "util/static_graph.hpp"
-#include "util/typedefs.hpp"
-
-namespace osrm
-{
-namespace contractor
-{
-
-namespace detail
-{
-template <storage::Ownership Ownership>
-using QueryGraph = util::StaticGraph<typename QueryEdge::EdgeData, Ownership>;
-}
-
-using QueryGraph = detail::QueryGraph<storage::Ownership::Container>;
-using QueryGraphView = detail::QueryGraph<storage::Ownership::View>;
-}
-}
-
-#endif // QUERYEDGE_HPP

include/customizer/cell_customizer.hpp

@@ -5,8 +5,7 @@
 #include "partition/multi_level_partition.hpp"
 #include "util/binary_heap.hpp"
 
-#include <tbb/enumerable_thread_specific.h>
-
+#include <boost/thread/tss.hpp>
 #include <unordered_set>
 
 namespace osrm
@@ -16,22 +15,12 @@ namespace customizer
 
 class CellCustomizer
 {
-  private:
-    struct HeapData
-    {
-        bool from_clique;
-    };
 
   public:
-    using Heap =
-        util::BinaryHeap<NodeID, NodeID, EdgeWeight, HeapData, util::ArrayStorage<NodeID, int>>;
-    using HeapPtr = tbb::enumerable_thread_specific<Heap>;
-
     CellCustomizer(const partition::MultiLevelPartition &partition) : partition(partition) {}
 
     template <typename GraphT>
-    void Customize(
-        const GraphT &graph, Heap &heap, partition::CellStorage &cells, LevelID level, CellID id)
+    void Customize(const GraphT &graph, partition::CellStorage &cells, LevelID level, CellID id)
     {
         auto cell = cells.GetCell(level, id);
         auto destinations = cell.GetDestinationNodes();
@@ -40,8 +29,8 @@ class CellCustomizer
         for (auto source : cell.GetSourceNodes())
         {
             std::unordered_set<NodeID> destinations_set(destinations.begin(), destinations.end());
-            heap.Clear();
-            heap.Insert(source, 0, {false});
+            Heap heap(graph.GetNumberOfNodes());
+            heap.Insert(source, 0, {});
 
             // explore search space
             while (!heap.Empty() && !destinations_set.empty())
@@ -71,23 +60,26 @@ class CellCustomizer
 
     template <typename GraphT> void Customize(const GraphT &graph, partition::CellStorage &cells)
     {
-        Heap heap_exemplar(graph.GetNumberOfNodes());
-        HeapPtr heaps(heap_exemplar);
-
         for (std::size_t level = 1; level < partition.GetNumberOfLevels(); ++level)
         {
             tbb::parallel_for(tbb::blocked_range<std::size_t>(0, partition.GetNumberOfCells(level)),
                               [&](const tbb::blocked_range<std::size_t> &range) {
-                                  auto &heap = heaps.local();
                                   for (auto id = range.begin(), end = range.end(); id != end; ++id)
                                   {
-                                      Customize(graph, heap, cells, level, id);
+                                      Customize(graph, cells, level, id);
                                   }
                               });
         }
     }
 
   private:
+    struct HeapData
+    {
+    };
+    using Heap = util::
+        BinaryHeap<NodeID, NodeID, EdgeWeight, HeapData, util::UnorderedMapStorage<NodeID, int>>;
+    using HeapPtr = boost::thread_specific_ptr<Heap>;
+
     template <bool first_level, typename GraphT>
     void RelaxNode(const GraphT &graph,
                    const partition::CellStorage &cells,
@@ -96,42 +88,29 @@ class CellCustomizer
                    NodeID node,
                    EdgeWeight weight) const
     {
-        BOOST_ASSERT(heap.WasInserted(node));
-
         if (!first_level)
         {
-            // if we reaches this node from a clique arc we don't need to scan
-            // the clique arcs again because of the triangle inequality
-            //
-            // d(parent, node) + d(node, v) >= d(parent, v)
-            //
-            // And if there is a path (parent, node, v) there must also be a
-            // clique arc (parent, v) with d(parent, v).
-            if (!heap.GetData(node).from_clique)
+            // Relax sub-cell nodes
+            auto subcell_id = partition.GetCell(level - 1, node);
+            auto subcell = cells.GetCell(level - 1, subcell_id);
+            auto subcell_destination = subcell.GetDestinationNodes().begin();
+            for (auto subcell_weight : subcell.GetOutWeight(node))
             {
-                // Relax sub-cell nodes
-                auto subcell_id = partition.GetCell(level - 1, node);
-                auto subcell = cells.GetCell(level - 1, subcell_id);
-                auto subcell_destination = subcell.GetDestinationNodes().begin();
-                for (auto subcell_weight : subcell.GetOutWeight(node))
+                if (subcell_weight != INVALID_EDGE_WEIGHT)
                 {
-                    if (subcell_weight != INVALID_EDGE_WEIGHT)
+                    const NodeID to = *subcell_destination;
+                    const EdgeWeight to_weight = subcell_weight + weight;
+                    if (!heap.WasInserted(to))
                     {
-                        const NodeID to = *subcell_destination;
-                        const EdgeWeight to_weight = subcell_weight + weight;
-                        if (!heap.WasInserted(to))
-                        {
-                            heap.Insert(to, to_weight, {true});
-                        }
-                        else if (to_weight < heap.GetKey(to))
-                        {
-                            heap.DecreaseKey(to, to_weight);
-                            heap.GetData(to).from_clique = true;
-                        }
+                        heap.Insert(to, to_weight, {});
+                    }
+                    else if (to_weight < heap.GetKey(to))
+                    {
+                        heap.DecreaseKey(to, to_weight);
                     }
-
-                    ++subcell_destination;
                 }
+
+                ++subcell_destination;
             }
         }
 
@@ -147,12 +126,11 @@ class CellCustomizer
                 const EdgeWeight to_weight = data.weight + weight;
                 if (!heap.WasInserted(to))
                 {
-                    heap.Insert(to, to_weight, {false});
+                    heap.Insert(to, to_weight, {});
                 }
                 else if (to_weight < heap.GetKey(to))
                 {
                     heap.DecreaseKey(to, to_weight);
-                    heap.GetData(to).from_clique = false;
                 }
             }
         }

include/customizer/edge_based_graph.hpp

@@ -7,8 +7,6 @@
 #include "util/static_graph.hpp"
 #include "util/typedefs.hpp"
 
-#include "storage/shared_memory_ownership.hpp"
-
 #include <boost/filesystem/path.hpp>
 
 namespace osrm
@@ -18,17 +16,16 @@ namespace customizer
 
 using EdgeBasedGraphEdgeData = partition::EdgeBasedGraphEdgeData;
 
-struct MultiLevelEdgeBasedGraph
-    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>
+struct MultiLevelEdgeBasedGraph : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, false>
 {
-    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
+    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, false>;
     using Base::Base;
 };
 
 struct MultiLevelEdgeBasedGraphView
-    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>
+    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, true>
 {
-    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
+    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, true>;
     using Base::Base;
 };
 

include/customizer/io.hpp

@@ -0,0 +1,18 @@
+#ifndef OSRM_CUSTOMIZER_IO_HPP
+#define OSRM_CUSTOMIZER_IO_HPP
+
+#include "customizer/edge_based_graph.hpp"
+
+#include "storage/io.hpp"
+
+namespace osrm
+{
+namespace customizer
+{
+namespace io
+{
+}
+}
+}
+
+#endif

include/engine/algorithm.hpp

@@ -7,36 +7,30 @@ namespace osrm
 {
 namespace engine
 {
-namespace routing_algorithms
+namespace algorithm
 {
 
 // Contraction Hiearchy
-namespace ch
-{
-struct Algorithm final
+struct CH final
 {
 };
-}
 // Contraction Hiearchy with core
-namespace corech
-{
-struct Algorithm final
+struct CoreCH final
 {
 };
-}
 // Multi-Level Dijkstra
-namespace mld
-{
-struct Algorithm final
+struct MLD final
 {
 };
+
+template <typename AlgorithmT> const char *name();
+template <> inline const char *name<CH>() { return "CH"; }
+template <> inline const char *name<CoreCH>() { return "CoreCH"; }
+template <> inline const char *name<MLD>() { return "MLD"; }
 }
 
-// Algorithm names
-template <typename AlgorithmT> const char *name();
-template <> inline const char *name<ch::Algorithm>() { return "CH"; }
-template <> inline const char *name<corech::Algorithm>() { return "CoreCH"; }
-template <> inline const char *name<mld::Algorithm>() { return "MLD"; }
+namespace algorithm_trais
+{
 
 template <typename AlgorithmT> struct HasAlternativePathSearch final : std::false_type
 {
@@ -57,49 +51,62 @@ template <typename AlgorithmT> struct HasGetTileTurns final : std::false_type
 {
 };
 
-// Algorithms supported by Contraction Hierarchies
-template <> struct HasAlternativePathSearch<ch::Algorithm> final : std::true_type
+template <> struct HasAlternativePathSearch<algorithm::CH> final : std::true_type
 {
 };
-template <> struct HasShortestPathSearch<ch::Algorithm> final : std::true_type
+template <> struct HasShortestPathSearch<algorithm::CH> final : std::true_type
 {
 };
-template <> struct HasDirectShortestPathSearch<ch::Algorithm> final : std::true_type
+template <> struct HasDirectShortestPathSearch<algorithm::CH> final : std::true_type
 {
 };
-template <> struct HasMapMatching<ch::Algorithm> final : std::true_type
+template <> struct HasMapMatching<algorithm::CH> final : std::true_type
 {
 };
-template <> struct HasManyToManySearch<ch::Algorithm> final : std::true_type
+template <> struct HasManyToManySearch<algorithm::CH> final : std::true_type
 {
 };
-template <> struct HasGetTileTurns<ch::Algorithm> final : std::true_type
+template <> struct HasGetTileTurns<algorithm::CH> final : std::true_type
 {
 };
 
-// Algorithms supported by Contraction Hierarchies with core
-// the rest is disabled because of performance reasons
-template <> struct HasShortestPathSearch<corech::Algorithm> final : std::true_type
+// disbaled because of perfomance reasons
+template <> struct HasAlternativePathSearch<algorithm::CoreCH> final : std::false_type
 {
 };
-template <> struct HasDirectShortestPathSearch<corech::Algorithm> final : std::true_type
+template <> struct HasManyToManySearch<algorithm::CoreCH> final : std::false_type
 {
 };
-template <> struct HasMapMatching<corech::Algorithm> final : std::true_type
+template <> struct HasShortestPathSearch<algorithm::CoreCH> final : std::true_type
 {
 };
-template <> struct HasGetTileTurns<corech::Algorithm> final : std::true_type
+template <> struct HasDirectShortestPathSearch<algorithm::CoreCH> final : std::true_type
+{
+};
+template <> struct HasMapMatching<algorithm::CoreCH> final : std::true_type
+{
+};
+template <> struct HasGetTileTurns<algorithm::CoreCH> final : std::true_type
 {
 };
 
-// Algorithms supported by Multi-Level Dijkstra
-template <> struct HasDirectShortestPathSearch<mld::Algorithm> final : std::true_type
+// disbaled because of perfomance reasons
+template <> struct HasAlternativePathSearch<algorithm::MLD> final : std::false_type
 {
 };
-template <> struct HasShortestPathSearch<mld::Algorithm> final : std::true_type
+template <> struct HasManyToManySearch<algorithm::MLD> final : std::false_type
 {
 };
-template <> struct HasMapMatching<mld::Algorithm> final : std::true_type
+template <> struct HasShortestPathSearch<algorithm::MLD> final : std::false_type
+{
+};
+template <> struct HasDirectShortestPathSearch<algorithm::MLD> final : std::true_type
+{
+};
+template <> struct HasMapMatching<algorithm::MLD> final : std::false_type
+{
+};
+template <> struct HasGetTileTurns<algorithm::MLD> final : std::false_type
 {
 };
 }

include/engine/api/match_parameters_tidy.hpp

@@ -85,6 +85,7 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
     result.can_be_removed.resize(params.coordinates.size(), false);
 
     result.tidied_to_original.push_back(0);
+    std::size_t last_good = 0;
 
     const auto uses_timestamps = !params.timestamps.empty();
 
@@ -108,6 +109,7 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
 
             if (over_distance && over_duration)
             {
+                last_good = next;
                 result.tidied_to_original.push_back(next);
                 running = {0., 0}; // reset running distance and time
             }
@@ -120,6 +122,7 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
         {
             if (over_distance)
             {
+                last_good = next;
                 result.tidied_to_original.push_back(next);
                 running = {0., 0}; // reset running distance and time
             }

include/engine/datafacade/algorithm_datafacade.hpp

@@ -17,16 +17,11 @@ namespace engine
 namespace datafacade
 {
 
-// Namespace local aliases for algorithms
-using CH = routing_algorithms::ch::Algorithm;
-using CoreCH = routing_algorithms::corech::Algorithm;
-using MLD = routing_algorithms::mld::Algorithm;
-
 using EdgeRange = util::range<EdgeID>;
 
 template <typename AlgorithmT> class AlgorithmDataFacade;
 
-template <> class AlgorithmDataFacade<CH>
+template <> class AlgorithmDataFacade<algorithm::CH>
 {
   public:
     using EdgeData = contractor::QueryEdge::EdgeData;
@@ -61,7 +56,7 @@ template <> class AlgorithmDataFacade<CH>
                                     const std::function<bool(EdgeData)> filter) const = 0;
 };
 
-template <> class AlgorithmDataFacade<CoreCH>
+template <> class AlgorithmDataFacade<algorithm::CoreCH>
 {
   public:
     using EdgeData = contractor::QueryEdge::EdgeData;
@@ -69,7 +64,7 @@ template <> class AlgorithmDataFacade<CoreCH>
     virtual bool IsCoreNode(const NodeID id) const = 0;
 };
 
-template <> class AlgorithmDataFacade<MLD>
+template <> class AlgorithmDataFacade<algorithm::MLD>
 {
   public:
     using EdgeData = extractor::EdgeBasedEdge::EdgeData;

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -15,15 +15,11 @@
 #include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/profile_properties.hpp"
 #include "extractor/segment_data_container.hpp"
-#include "extractor/turn_data_container.hpp"
-
-#include "contractor/query_graph.hpp"
 
 #include "partition/cell_storage.hpp"
 #include "partition/multi_level_partition.hpp"
 
 #include "storage/shared_datatype.hpp"
-#include "storage/shared_memory_ownership.hpp"
 
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
@@ -61,14 +57,15 @@ namespace datafacade
 template <typename AlgorithmT> class ContiguousInternalMemoryAlgorithmDataFacade;
 
 template <>
-class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::AlgorithmDataFacade<CH>
+class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>
+    : public datafacade::AlgorithmDataFacade<algorithm::CH>
 {
   private:
-    using QueryGraph = contractor::QueryGraphView;
+    using QueryGraph = util::StaticGraph<EdgeData, true>;
     using GraphNode = QueryGraph::NodeArrayEntry;
     using GraphEdge = QueryGraph::EdgeArrayEntry;
 
-    QueryGraph m_query_graph;
+    std::unique_ptr<QueryGraph> m_query_graph;
 
     // allocator that keeps the allocation data
     std::shared_ptr<ContiguousBlockAllocator> allocator;
@@ -81,11 +78,11 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
         auto graph_edges_ptr = data_layout.GetBlockPtr<GraphEdge>(
             memory_block, storage::DataLayout::CH_GRAPH_EDGE_LIST);
 
-        util::vector_view<GraphNode> node_list(
+        util::ShM<GraphNode, true>::vector node_list(
             graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::CH_GRAPH_NODE_LIST]);
-        util::vector_view<GraphEdge> edge_list(
+        util::ShM<GraphEdge, true>::vector edge_list(
             graph_edges_ptr, data_layout.num_entries[storage::DataLayout::CH_GRAPH_EDGE_LIST]);
-        m_query_graph = QueryGraph(node_list, edge_list);
+        m_query_graph.reset(new QueryGraph(node_list, edge_list));
     }
 
   public:
@@ -102,62 +99,62 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
     }
 
     // search graph access
-    unsigned GetNumberOfNodes() const override final { return m_query_graph.GetNumberOfNodes(); }
+    unsigned GetNumberOfNodes() const override final { return m_query_graph->GetNumberOfNodes(); }
 
-    unsigned GetNumberOfEdges() const override final { return m_query_graph.GetNumberOfEdges(); }
+    unsigned GetNumberOfEdges() const override final { return m_query_graph->GetNumberOfEdges(); }
 
     unsigned GetOutDegree(const NodeID n) const override final
     {
-        return m_query_graph.GetOutDegree(n);
+        return m_query_graph->GetOutDegree(n);
     }
 
-    NodeID GetTarget(const EdgeID e) const override final { return m_query_graph.GetTarget(e); }
+    NodeID GetTarget(const EdgeID e) const override final { return m_query_graph->GetTarget(e); }
 
-    const EdgeData &GetEdgeData(const EdgeID e) const override final
+    EdgeData &GetEdgeData(const EdgeID e) const override final
     {
-        return m_query_graph.GetEdgeData(e);
+        return m_query_graph->GetEdgeData(e);
     }
 
-    EdgeID BeginEdges(const NodeID n) const override final { return m_query_graph.BeginEdges(n); }
+    EdgeID BeginEdges(const NodeID n) const override final { return m_query_graph->BeginEdges(n); }
 
-    EdgeID EndEdges(const NodeID n) const override final { return m_query_graph.EndEdges(n); }
+    EdgeID EndEdges(const NodeID n) const override final { return m_query_graph->EndEdges(n); }
 
     EdgeRange GetAdjacentEdgeRange(const NodeID node) const override final
     {
-        return m_query_graph.GetAdjacentEdgeRange(node);
+        return m_query_graph->GetAdjacentEdgeRange(node);
     }
 
     // searches for a specific edge
     EdgeID FindEdge(const NodeID from, const NodeID to) const override final
     {
-        return m_query_graph.FindEdge(from, to);
+        return m_query_graph->FindEdge(from, to);
     }
 
     EdgeID FindEdgeInEitherDirection(const NodeID from, const NodeID to) const override final
     {
-        return m_query_graph.FindEdgeInEitherDirection(from, to);
+        return m_query_graph->FindEdgeInEitherDirection(from, to);
     }
 
     EdgeID
     FindEdgeIndicateIfReverse(const NodeID from, const NodeID to, bool &result) const override final
     {
-        return m_query_graph.FindEdgeIndicateIfReverse(from, to, result);
+        return m_query_graph->FindEdgeIndicateIfReverse(from, to, result);
     }
 
     EdgeID FindSmallestEdge(const NodeID from,
                             const NodeID to,
                             std::function<bool(EdgeData)> filter) const override final
     {
-        return m_query_graph.FindSmallestEdge(from, to, filter);
+        return m_query_graph->FindSmallestEdge(from, to, filter);
     }
 };
 
 template <>
-class ContiguousInternalMemoryAlgorithmDataFacade<CoreCH>
-    : public datafacade::AlgorithmDataFacade<CoreCH>
+class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CoreCH>
+    : public datafacade::AlgorithmDataFacade<algorithm::CoreCH>
 {
   private:
-    util::vector_view<bool> m_is_core_node;
+    util::ShM<bool, true>::vector m_is_core_node;
 
     // allocator that keeps the allocation data
     std::shared_ptr<ContiguousBlockAllocator> allocator;
@@ -166,7 +163,7 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CoreCH>
     {
         auto core_marker_ptr =
             data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::CH_CORE_MARKER);
-        util::vector_view<bool> is_core_node(
+        util::ShM<bool, true>::vector is_core_node(
             core_marker_ptr, data_layout.num_entries[storage::DataLayout::CH_CORE_MARKER]);
         m_is_core_node = std::move(is_core_node);
     }
@@ -202,9 +199,10 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 {
   private:
     using super = BaseDataFacade;
-    using IndexBlock = util::RangeTable<16, storage::Ownership::View>::BlockT;
+    using IndexBlock = util::RangeTable<16, true>::BlockT;
     using RTreeLeaf = super::RTreeLeaf;
-    using SharedRTree = util::StaticRTree<RTreeLeaf, storage::Ownership::View>;
+    using SharedRTree =
+        util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, true>::vector, true>;
     using SharedGeospatialQuery = GeospatialQuery<SharedRTree, BaseDataFacade>;
     using RTreeNode = SharedRTree::TreeNode;
 
@@ -213,20 +211,28 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     extractor::Datasources *m_datasources;
 
     unsigned m_check_sum;
-    util::vector_view<util::Coordinate> m_coordinate_list;
-    util::PackedVectorView<OSMNodeID> m_osmnodeid_list;
+    util::ShM<util::Coordinate, true>::vector m_coordinate_list;
+    util::PackedVector<OSMNodeID, true> m_osmnodeid_list;
+    util::ShM<GeometryID, true>::vector m_via_geometry_list;
+    util::ShM<NameID, true>::vector m_name_ID_list;
+    util::ShM<LaneDataID, true>::vector m_lane_data_id;
+    util::ShM<extractor::guidance::TurnInstruction, true>::vector m_turn_instruction_list;
+    util::ShM<extractor::TravelMode, true>::vector m_travel_mode_list;
+    util::ShM<util::guidance::TurnBearing, true>::vector m_pre_turn_bearing;
+    util::ShM<util::guidance::TurnBearing, true>::vector m_post_turn_bearing;
     util::NameTable m_names_table;
-    util::vector_view<std::uint32_t> m_lane_description_offsets;
-    util::vector_view<extractor::guidance::TurnLaneType::Mask> m_lane_description_masks;
-    util::vector_view<TurnPenalty> m_turn_weight_penalties;
-    util::vector_view<TurnPenalty> m_turn_duration_penalties;
+    util::ShM<unsigned, true>::vector m_name_begin_indices;
+    util::ShM<bool, true>::vector m_is_core_node;
+    util::ShM<std::uint32_t, true>::vector m_lane_description_offsets;
+    util::ShM<extractor::guidance::TurnLaneType::Mask, true>::vector m_lane_description_masks;
+    util::ShM<TurnPenalty, true>::vector m_turn_weight_penalties;
+    util::ShM<TurnPenalty, true>::vector m_turn_duration_penalties;
     extractor::SegmentDataView segment_data;
-    extractor::TurnDataView turn_data;
 
-    util::vector_view<char> m_datasource_name_data;
-    util::vector_view<std::size_t> m_datasource_name_offsets;
-    util::vector_view<std::size_t> m_datasource_name_lengths;
-    util::vector_view<util::guidance::LaneTupleIdPair> m_lane_tupel_id_pairs;
+    util::ShM<char, true>::vector m_datasource_name_data;
+    util::ShM<std::size_t, true>::vector m_datasource_name_offsets;
+    util::ShM<std::size_t, true>::vector m_datasource_name_lengths;
+    util::ShM<util::guidance::LaneTupleIdPair, true>::vector m_lane_tupel_id_pairs;
 
     std::unique_ptr<SharedRTree> m_static_rtree;
     std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
@@ -234,17 +240,17 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     util::NameTable m_name_table;
     // bearing classes by node based node
-    util::vector_view<BearingClassID> m_bearing_class_id_table;
+    util::ShM<BearingClassID, true>::vector m_bearing_class_id_table;
     // entry class IDs
-    util::vector_view<EntryClassID> m_entry_class_id_list;
+    util::ShM<EntryClassID, true>::vector m_entry_class_id_list;
 
     // the look-up table for entry classes. An entry class lists the possibility of entry for all
     // available turns. Such a class id is stored with every edge.
-    util::vector_view<util::guidance::EntryClass> m_entry_class_table;
+    util::ShM<util::guidance::EntryClass, true>::vector m_entry_class_table;
     // the look-up table for distinct bearing classes. A bearing class lists the available bearings
     // at an intersection
-    std::shared_ptr<util::RangeTable<16, storage::Ownership::View>> m_bearing_ranges_table;
-    util::vector_view<DiscreteBearing> m_bearing_values_table;
+    std::shared_ptr<util::RangeTable<16, true>> m_bearing_ranges_table;
+    util::ShM<DiscreteBearing, true>::vector m_bearing_values_table;
 
     // allocator that keeps the allocation data
     std::shared_ptr<ContiguousBlockAllocator> allocator;
@@ -297,7 +303,8 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
             new SharedGeospatialQuery(*m_static_rtree, m_coordinate_list, *this));
     }
 
-    void InitializeNodeInformationPointers(storage::DataLayout &data_layout, char *memory_block)
+    void InitializeNodeAndEdgeInformationPointers(storage::DataLayout &data_layout,
+                                                  char *memory_block)
     {
         const auto coordinate_list_ptr = data_layout.GetBlockPtr<util::Coordinate>(
             memory_block, storage::DataLayout::COORDINATE_LIST);
@@ -316,59 +323,66 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         // We (ab)use the number of coordinates here because we know we have the same amount of ids
         m_osmnodeid_list.set_number_of_entries(
             data_layout.num_entries[storage::DataLayout::COORDINATE_LIST]);
-    }
 
-    void InitializeEdgeInformationPointers(storage::DataLayout &layout, char *memory_ptr)
-    {
-        auto via_geometry_list_ptr =
-            layout.GetBlockPtr<GeometryID>(memory_ptr, storage::DataLayout::VIA_NODE_LIST);
-        util::vector_view<GeometryID> geometry_ids(
-            via_geometry_list_ptr, layout.num_entries[storage::DataLayout::VIA_NODE_LIST]);
-
-        const auto travel_mode_list_ptr =
-            layout.GetBlockPtr<extractor::TravelMode>(memory_ptr, storage::DataLayout::TRAVEL_MODE);
-        util::vector_view<extractor::TravelMode> travel_modes(
-            travel_mode_list_ptr, layout.num_entries[storage::DataLayout::TRAVEL_MODE]);
+        const auto travel_mode_list_ptr = data_layout.GetBlockPtr<extractor::TravelMode>(
+            memory_block, storage::DataLayout::TRAVEL_MODE);
+        util::ShM<extractor::TravelMode, true>::vector travel_mode_list(
+            travel_mode_list_ptr, data_layout.num_entries[storage::DataLayout::TRAVEL_MODE]);
+        m_travel_mode_list = std::move(travel_mode_list);
 
         const auto lane_data_id_ptr =
-            layout.GetBlockPtr<LaneDataID>(memory_ptr, storage::DataLayout::LANE_DATA_ID);
-        util::vector_view<LaneDataID> lane_data_ids(
-            lane_data_id_ptr, layout.num_entries[storage::DataLayout::LANE_DATA_ID]);
+            data_layout.GetBlockPtr<LaneDataID>(memory_block, storage::DataLayout::LANE_DATA_ID);
+        util::ShM<LaneDataID, true>::vector lane_data_id(
+            lane_data_id_ptr, data_layout.num_entries[storage::DataLayout::LANE_DATA_ID]);
+        m_lane_data_id = std::move(lane_data_id);
+
+        const auto lane_tupel_id_pair_ptr =
+            data_layout.GetBlockPtr<util::guidance::LaneTupleIdPair>(
+                memory_block, storage::DataLayout::TURN_LANE_DATA);
+        util::ShM<util::guidance::LaneTupleIdPair, true>::vector lane_tupel_id_pair(
+            lane_tupel_id_pair_ptr, data_layout.num_entries[storage::DataLayout::TURN_LANE_DATA]);
+        m_lane_tupel_id_pairs = std::move(lane_tupel_id_pair);
 
         const auto turn_instruction_list_ptr =
-            layout.GetBlockPtr<extractor::guidance::TurnInstruction>(
-                memory_ptr, storage::DataLayout::TURN_INSTRUCTION);
-        util::vector_view<extractor::guidance::TurnInstruction> turn_instructions(
-            turn_instruction_list_ptr, layout.num_entries[storage::DataLayout::TURN_INSTRUCTION]);
+            data_layout.GetBlockPtr<extractor::guidance::TurnInstruction>(
+                memory_block, storage::DataLayout::TURN_INSTRUCTION);
+        util::ShM<extractor::guidance::TurnInstruction, true>::vector turn_instruction_list(
+            turn_instruction_list_ptr,
+            data_layout.num_entries[storage::DataLayout::TURN_INSTRUCTION]);
+        m_turn_instruction_list = std::move(turn_instruction_list);
 
         const auto name_id_list_ptr =
-            layout.GetBlockPtr<NameID>(memory_ptr, storage::DataLayout::NAME_ID_LIST);
-        util::vector_view<NameID> name_ids(name_id_list_ptr,
-                                           layout.num_entries[storage::DataLayout::NAME_ID_LIST]);
+            data_layout.GetBlockPtr<NameID>(memory_block, storage::DataLayout::NAME_ID_LIST);
+        util::ShM<NameID, true>::vector name_id_list(
+            name_id_list_ptr, data_layout.num_entries[storage::DataLayout::NAME_ID_LIST]);
+        m_name_ID_list = std::move(name_id_list);
 
         const auto entry_class_id_list_ptr =
-            layout.GetBlockPtr<EntryClassID>(memory_ptr, storage::DataLayout::ENTRY_CLASSID);
-        util::vector_view<EntryClassID> entry_class_ids(
-            entry_class_id_list_ptr, layout.num_entries[storage::DataLayout::ENTRY_CLASSID]);
+            data_layout.GetBlockPtr<EntryClassID>(memory_block, storage::DataLayout::ENTRY_CLASSID);
+        typename util::ShM<EntryClassID, true>::vector entry_class_id_list(
+            entry_class_id_list_ptr, data_layout.num_entries[storage::DataLayout::ENTRY_CLASSID]);
+        m_entry_class_id_list = std::move(entry_class_id_list);
 
-        const auto pre_turn_bearing_ptr = layout.GetBlockPtr<util::guidance::TurnBearing>(
-            memory_ptr, storage::DataLayout::PRE_TURN_BEARING);
-        util::vector_view<util::guidance::TurnBearing> pre_turn_bearings(
-            pre_turn_bearing_ptr, layout.num_entries[storage::DataLayout::PRE_TURN_BEARING]);
+        const auto pre_turn_bearing_ptr = data_layout.GetBlockPtr<util::guidance::TurnBearing>(
+            memory_block, storage::DataLayout::PRE_TURN_BEARING);
+        typename util::ShM<util::guidance::TurnBearing, true>::vector pre_turn_bearing(
+            pre_turn_bearing_ptr, data_layout.num_entries[storage::DataLayout::PRE_TURN_BEARING]);
+        m_pre_turn_bearing = std::move(pre_turn_bearing);
 
-        const auto post_turn_bearing_ptr = layout.GetBlockPtr<util::guidance::TurnBearing>(
-            memory_ptr, storage::DataLayout::POST_TURN_BEARING);
-        util::vector_view<util::guidance::TurnBearing> post_turn_bearings(
-            post_turn_bearing_ptr, layout.num_entries[storage::DataLayout::POST_TURN_BEARING]);
+        const auto post_turn_bearing_ptr = data_layout.GetBlockPtr<util::guidance::TurnBearing>(
+            memory_block, storage::DataLayout::POST_TURN_BEARING);
+        typename util::ShM<util::guidance::TurnBearing, true>::vector post_turn_bearing(
+            post_turn_bearing_ptr, data_layout.num_entries[storage::DataLayout::POST_TURN_BEARING]);
+        m_post_turn_bearing = std::move(post_turn_bearing);
+    }
 
-        turn_data = extractor::TurnDataView(std::move(geometry_ids),
-                                            std::move(name_ids),
-                                            std::move(turn_instructions),
-                                            std::move(lane_data_ids),
-                                            std::move(travel_modes),
-                                            std::move(entry_class_ids),
-                                            std::move(pre_turn_bearings),
-                                            std::move(post_turn_bearings));
+    void InitializeViaNodeListPointer(storage::DataLayout &data_layout, char *memory_block)
+    {
+        auto via_geometry_list_ptr =
+            data_layout.GetBlockPtr<GeometryID>(memory_block, storage::DataLayout::VIA_NODE_LIST);
+        util::ShM<GeometryID, true>::vector via_geometry_list(
+            via_geometry_list_ptr, data_layout.num_entries[storage::DataLayout::VIA_NODE_LIST]);
+        m_via_geometry_list = std::move(via_geometry_list);
     }
 
     void InitializeNamePointers(storage::DataLayout &data_layout, char *memory_block)
@@ -384,35 +398,28 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         auto offsets_ptr = data_layout.GetBlockPtr<std::uint32_t>(
             memory_block, storage::DataLayout::LANE_DESCRIPTION_OFFSETS);
-        util::vector_view<std::uint32_t> offsets(
+        util::ShM<std::uint32_t, true>::vector offsets(
             offsets_ptr, data_layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_OFFSETS]);
         m_lane_description_offsets = std::move(offsets);
 
         auto masks_ptr = data_layout.GetBlockPtr<extractor::guidance::TurnLaneType::Mask>(
             memory_block, storage::DataLayout::LANE_DESCRIPTION_MASKS);
 
-        util::vector_view<extractor::guidance::TurnLaneType::Mask> masks(
+        util::ShM<extractor::guidance::TurnLaneType::Mask, true>::vector masks(
             masks_ptr, data_layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_MASKS]);
         m_lane_description_masks = std::move(masks);
-
-        const auto lane_tupel_id_pair_ptr =
-            data_layout.GetBlockPtr<util::guidance::LaneTupleIdPair>(
-                memory_block, storage::DataLayout::TURN_LANE_DATA);
-        util::vector_view<util::guidance::LaneTupleIdPair> lane_tupel_id_pair(
-            lane_tupel_id_pair_ptr, data_layout.num_entries[storage::DataLayout::TURN_LANE_DATA]);
-        m_lane_tupel_id_pairs = std::move(lane_tupel_id_pair);
     }
 
     void InitializeTurnPenalties(storage::DataLayout &data_layout, char *memory_block)
     {
         auto turn_weight_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>(
             memory_block, storage::DataLayout::TURN_WEIGHT_PENALTIES);
-        m_turn_weight_penalties = util::vector_view<TurnPenalty>(
+        m_turn_weight_penalties = util::ShM<TurnPenalty, true>::vector(
             turn_weight_penalties_ptr,
             data_layout.num_entries[storage::DataLayout::TURN_WEIGHT_PENALTIES]);
         auto turn_duration_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>(
             memory_block, storage::DataLayout::TURN_DURATION_PENALTIES);
-        m_turn_duration_penalties = util::vector_view<TurnPenalty>(
+        m_turn_duration_penalties = util::ShM<TurnPenalty, true>::vector(
             turn_duration_penalties_ptr,
             data_layout.num_entries[storage::DataLayout::TURN_DURATION_PENALTIES]);
     }
@@ -421,42 +428,42 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         auto geometries_index_ptr =
             data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::GEOMETRIES_INDEX);
-        util::vector_view<unsigned> geometry_begin_indices(
+        util::ShM<unsigned, true>::vector geometry_begin_indices(
             geometries_index_ptr, data_layout.num_entries[storage::DataLayout::GEOMETRIES_INDEX]);
 
         auto geometries_node_list_ptr = data_layout.GetBlockPtr<NodeID>(
             memory_block, storage::DataLayout::GEOMETRIES_NODE_LIST);
-        util::vector_view<NodeID> geometry_node_list(
+        util::ShM<NodeID, true>::vector geometry_node_list(
             geometries_node_list_ptr,
             data_layout.num_entries[storage::DataLayout::GEOMETRIES_NODE_LIST]);
 
         auto geometries_fwd_weight_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
             memory_block, storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST);
-        util::vector_view<EdgeWeight> geometry_fwd_weight_list(
+        util::ShM<EdgeWeight, true>::vector geometry_fwd_weight_list(
             geometries_fwd_weight_list_ptr,
             data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST]);
 
         auto geometries_rev_weight_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
             memory_block, storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST);
-        util::vector_view<EdgeWeight> geometry_rev_weight_list(
+        util::ShM<EdgeWeight, true>::vector geometry_rev_weight_list(
             geometries_rev_weight_list_ptr,
             data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST]);
 
         auto geometries_fwd_duration_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
             memory_block, storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST);
-        util::vector_view<EdgeWeight> geometry_fwd_duration_list(
+        util::ShM<EdgeWeight, true>::vector geometry_fwd_duration_list(
             geometries_fwd_duration_list_ptr,
             data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST]);
 
         auto geometries_rev_duration_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
             memory_block, storage::DataLayout::GEOMETRIES_REV_DURATION_LIST);
-        util::vector_view<EdgeWeight> geometry_rev_duration_list(
+        util::ShM<EdgeWeight, true>::vector geometry_rev_duration_list(
             geometries_rev_duration_list_ptr,
             data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_DURATION_LIST]);
 
         auto datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
             memory_block, storage::DataLayout::DATASOURCES_LIST);
-        util::vector_view<DatasourceID> datasources_list(
+        util::ShM<DatasourceID, true>::vector datasources_list(
             datasources_list_ptr, data_layout.num_entries[storage::DataLayout::DATASOURCES_LIST]);
 
         segment_data = extractor::SegmentDataView{std::move(geometry_begin_indices),
@@ -475,13 +482,13 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         auto bearing_class_id_ptr = data_layout.GetBlockPtr<BearingClassID>(
             memory_block, storage::DataLayout::BEARING_CLASSID);
-        typename util::vector_view<BearingClassID> bearing_class_id_table(
+        typename util::ShM<BearingClassID, true>::vector bearing_class_id_table(
             bearing_class_id_ptr, data_layout.num_entries[storage::DataLayout::BEARING_CLASSID]);
         m_bearing_class_id_table = std::move(bearing_class_id_table);
 
         auto bearing_class_ptr = data_layout.GetBlockPtr<DiscreteBearing>(
             memory_block, storage::DataLayout::BEARING_VALUES);
-        typename util::vector_view<DiscreteBearing> bearing_class_table(
+        typename util::ShM<DiscreteBearing, true>::vector bearing_class_table(
             bearing_class_ptr, data_layout.num_entries[storage::DataLayout::BEARING_VALUES]);
         m_bearing_values_table = std::move(bearing_class_table);
 
@@ -489,17 +496,17 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
             data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::BEARING_OFFSETS);
         auto blocks_ptr =
             data_layout.GetBlockPtr<IndexBlock>(memory_block, storage::DataLayout::BEARING_BLOCKS);
-        util::vector_view<unsigned> bearing_offsets(
+        util::ShM<unsigned, true>::vector bearing_offsets(
             offsets_ptr, data_layout.num_entries[storage::DataLayout::BEARING_OFFSETS]);
-        util::vector_view<IndexBlock> bearing_blocks(
+        util::ShM<IndexBlock, true>::vector bearing_blocks(
             blocks_ptr, data_layout.num_entries[storage::DataLayout::BEARING_BLOCKS]);
 
-        m_bearing_ranges_table = std::make_unique<util::RangeTable<16, storage::Ownership::View>>(
+        m_bearing_ranges_table = std::make_unique<util::RangeTable<16, true>>(
             bearing_offsets, bearing_blocks, static_cast<unsigned>(m_bearing_values_table.size()));
 
         auto entry_class_ptr = data_layout.GetBlockPtr<util::guidance::EntryClass>(
             memory_block, storage::DataLayout::ENTRY_CLASS);
-        typename util::vector_view<util::guidance::EntryClass> entry_class_table(
+        typename util::ShM<util::guidance::EntryClass, true>::vector entry_class_table(
             entry_class_ptr, data_layout.num_entries[storage::DataLayout::ENTRY_CLASS]);
         m_entry_class_table = std::move(entry_class_table);
     }
@@ -507,11 +514,11 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     void InitializeInternalPointers(storage::DataLayout &data_layout, char *memory_block)
     {
         InitializeChecksumPointer(data_layout, memory_block);
-        InitializeNodeInformationPointers(data_layout, memory_block);
-        InitializeEdgeInformationPointers(data_layout, memory_block);
+        InitializeNodeAndEdgeInformationPointers(data_layout, memory_block);
         InitializeTurnPenalties(data_layout, memory_block);
         InitializeGeometryPointers(data_layout, memory_block);
         InitializeTimestampPointer(data_layout, memory_block);
+        InitializeViaNodeListPointer(data_layout, memory_block);
         InitializeNamePointers(data_layout, memory_block);
         InitializeTurnLaneDescriptionsPointers(data_layout, memory_block);
         InitializeProfilePropertiesPointer(data_layout, memory_block);
@@ -600,7 +607,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     virtual GeometryID GetGeometryIndexForEdgeID(const EdgeID id) const override final
     {
-        return turn_data.GetGeometryID(id);
+        return m_via_geometry_list.at(id);
     }
 
     virtual TurnPenalty GetWeightPenaltyForEdgeID(const unsigned id) const override final
@@ -618,12 +625,12 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     extractor::guidance::TurnInstruction
     GetTurnInstructionForEdgeID(const EdgeID id) const override final
     {
-        return turn_data.GetTurnInstruction(id);
+        return m_turn_instruction_list.at(id);
     }
 
     extractor::TravelMode GetTravelModeForEdgeID(const EdgeID id) const override final
     {
-        return turn_data.GetTravelMode(id);
+        return m_travel_mode_list.at(id);
     }
 
     std::vector<RTreeLeaf> GetEdgesInBox(const util::Coordinate south_west,
@@ -745,7 +752,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     NameID GetNameIndexFromEdgeID(const EdgeID id) const override final
     {
-        return turn_data.GetNameID(id);
+        return m_name_ID_list.at(id);
     }
 
     StringView GetNameForID(const NameID id) const override final
@@ -817,16 +824,16 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     EntryClassID GetEntryClassID(const EdgeID eid) const override final
     {
-        return turn_data.GetEntryClassID(eid);
+        return m_entry_class_id_list.at(eid);
     }
 
     util::guidance::TurnBearing PreTurnBearing(const EdgeID eid) const override final
     {
-        return turn_data.GetPreTurnBearing(eid);
+        return m_pre_turn_bearing.at(eid);
     }
     util::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const override final
     {
-        return turn_data.GetPostTurnBearing(eid);
+        return m_post_turn_bearing.at(eid);
     }
 
     util::guidance::EntryClass GetEntryClass(const EntryClassID entry_class_id) const override final
@@ -834,12 +841,15 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return m_entry_class_table.at(entry_class_id);
     }
 
-    bool HasLaneData(const EdgeID id) const override final { return turn_data.HasLaneData(id); }
+    bool hasLaneData(const EdgeID id) const override final
+    {
+        return INVALID_LANE_DATAID != m_lane_data_id.at(id);
+    }
 
     util::guidance::LaneTupleIdPair GetLaneData(const EdgeID id) const override final
     {
-        BOOST_ASSERT(HasLaneData(id));
-        return m_lane_tupel_id_pairs.at(turn_data.GetLaneDataID(id));
+        BOOST_ASSERT(hasLaneData(id));
+        return m_lane_tupel_id_pairs.at(m_lane_data_id.at(id));
     }
 
     extractor::guidance::TurnLaneDescription
@@ -858,34 +868,36 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 template <typename AlgorithmT> class ContiguousInternalMemoryDataFacade;
 
 template <>
-class ContiguousInternalMemoryDataFacade<CH>
+class ContiguousInternalMemoryDataFacade<algorithm::CH>
     : public ContiguousInternalMemoryDataFacadeBase,
-      public ContiguousInternalMemoryAlgorithmDataFacade<CH>
+      public ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>
 {
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator)
         : ContiguousInternalMemoryDataFacadeBase(allocator),
-          ContiguousInternalMemoryAlgorithmDataFacade<CH>(allocator)
+          ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>(allocator)
 
     {
     }
 };
 
 template <>
-class ContiguousInternalMemoryDataFacade<CoreCH> final
-    : public ContiguousInternalMemoryDataFacade<CH>,
-      public ContiguousInternalMemoryAlgorithmDataFacade<CoreCH>
+class ContiguousInternalMemoryDataFacade<algorithm::CoreCH> final
+    : public ContiguousInternalMemoryDataFacade<algorithm::CH>,
+      public ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CoreCH>
 {
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator)
-        : ContiguousInternalMemoryDataFacade<CH>(allocator),
-          ContiguousInternalMemoryAlgorithmDataFacade<CoreCH>(allocator)
+        : ContiguousInternalMemoryDataFacade<algorithm::CH>(allocator),
+          ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CoreCH>(allocator)
 
     {
     }
 };
 
-template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public AlgorithmDataFacade<MLD>
+template <>
+class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
+    : public datafacade::AlgorithmDataFacade<algorithm::MLD>
 {
     // MLD data
     partition::MultiLevelPartitionView mld_partition;
@@ -910,20 +922,22 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
             BOOST_ASSERT(data_layout.GetBlockSize(storage::DataLayout::MLD_CELL_TO_CHILDREN) > 0);
 
             auto level_data =
-                data_layout.GetBlockPtr<partition::MultiLevelPartitionView::LevelData>(
+                *data_layout.GetBlockPtr<partition::MultiLevelPartitionView::LevelData>(
                     memory_block, storage::DataLayout::MLD_LEVEL_DATA);
 
             auto mld_partition_ptr = data_layout.GetBlockPtr<PartitionID>(
                 memory_block, storage::DataLayout::MLD_PARTITION);
             auto partition_entries_count =
                 data_layout.GetBlockEntries(storage::DataLayout::MLD_PARTITION);
-            util::vector_view<PartitionID> partition(mld_partition_ptr, partition_entries_count);
+            util::ShM<PartitionID, true>::vector partition(mld_partition_ptr,
+                                                           partition_entries_count);
 
             auto mld_chilren_ptr = data_layout.GetBlockPtr<CellID>(
                 memory_block, storage::DataLayout::MLD_CELL_TO_CHILDREN);
             auto children_entries_count =
                 data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_TO_CHILDREN);
-            util::vector_view<CellID> cell_to_children(mld_chilren_ptr, children_entries_count);
+            util::ShM<CellID, true>::vector cell_to_children(mld_chilren_ptr,
+                                                             children_entries_count);
 
             mld_partition =
                 partition::MultiLevelPartitionView{level_data, partition, cell_to_children};
@@ -955,15 +969,15 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
             auto cell_level_offsets_entries_count =
                 data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS);
 
-            util::vector_view<EdgeWeight> weights(mld_cell_weights_ptr, weight_entries_count);
-            util::vector_view<NodeID> source_boundary(mld_source_boundary_ptr,
-                                                      source_boundary_entries_count);
-            util::vector_view<NodeID> destination_boundary(mld_destination_boundary_ptr,
-                                                           destination_boundary_entries_count);
-            util::vector_view<partition::CellStorageView::CellData> cells(mld_cells_ptr,
-                                                                          cells_entries_counts);
-            util::vector_view<std::uint64_t> level_offsets(mld_cell_level_offsets_ptr,
-                                                           cell_level_offsets_entries_count);
+            util::ShM<EdgeWeight, true>::vector weights(mld_cell_weights_ptr, weight_entries_count);
+            util::ShM<NodeID, true>::vector source_boundary(mld_source_boundary_ptr,
+                                                            source_boundary_entries_count);
+            util::ShM<NodeID, true>::vector destination_boundary(
+                mld_destination_boundary_ptr, destination_boundary_entries_count);
+            util::ShM<partition::CellStorageView::CellData, true>::vector cells(
+                mld_cells_ptr, cells_entries_counts);
+            util::ShM<std::uint64_t, true>::vector level_offsets(mld_cell_level_offsets_ptr,
+                                                                 cell_level_offsets_entries_count);
 
             mld_cell_storage = partition::CellStorageView{std::move(weights),
                                                           std::move(source_boundary),
@@ -983,11 +997,11 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
         auto graph_node_to_offset_ptr = data_layout.GetBlockPtr<QueryGraph::EdgeOffset>(
             memory_block, storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET);
 
-        util::vector_view<GraphNode> node_list(
+        util::ShM<GraphNode, true>::vector node_list(
             graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_LIST]);
-        util::vector_view<GraphEdge> edge_list(
+        util::ShM<GraphEdge, true>::vector edge_list(
             graph_edges_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_EDGE_LIST]);
-        util::vector_view<QueryGraph::EdgeOffset> node_to_offset(
+        util::ShM<QueryGraph::EdgeOffset, true>::vector node_to_offset(
             graph_node_to_offset_ptr,
             data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET]);
 
@@ -1052,15 +1066,15 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
 };
 
 template <>
-class ContiguousInternalMemoryDataFacade<MLD> final
+class ContiguousInternalMemoryDataFacade<algorithm::MLD> final
     : public ContiguousInternalMemoryDataFacadeBase,
-      public ContiguousInternalMemoryAlgorithmDataFacade<MLD>
+      public ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
 {
   private:
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator)
         : ContiguousInternalMemoryDataFacadeBase(allocator),
-          ContiguousInternalMemoryAlgorithmDataFacade<MLD>(allocator)
+          ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>(allocator)
 
     {
     }

include/engine/datafacade/datafacade_base.hpp

@@ -130,7 +130,7 @@ class BaseDataFacade
                                                       const int bearing,
                                                       const int bearing_range) const = 0;
 
-    virtual bool HasLaneData(const EdgeID id) const = 0;
+    virtual bool hasLaneData(const EdgeID id) const = 0;
     virtual util::guidance::LaneTupleIdPair GetLaneData(const EdgeID id) const = 0;
     virtual extractor::guidance::TurnLaneDescription
     GetTurnDescription(const LaneDescriptionID lane_description_id) const = 0;

include/engine/engine.hpp

@@ -49,7 +49,7 @@ class EngineInterface
     virtual Status Tile(const api::TileParameters &parameters, std::string &result) const = 0;
 };
 
-template <typename Algorithm> class Engine final : public EngineInterface
+template <typename AlgorithmT> class Engine final : public EngineInterface
 {
   public:
     explicit Engine(const EngineConfig &config)
@@ -64,14 +64,15 @@ template <typename Algorithm> class Engine final : public EngineInterface
         if (config.use_shared_memory)
         {
             util::Log(logDEBUG) << "Using shared memory with algorithm "
-                                << routing_algorithms::name<Algorithm>();
-            facade_provider = std::make_unique<WatchingProvider<Algorithm>>();
+                                << algorithm::name<AlgorithmT>();
+            facade_provider = std::make_unique<WatchingProvider<AlgorithmT>>();
         }
         else
         {
             util::Log(logDEBUG) << "Using internal memory with algorithm "
-                                << routing_algorithms::name<Algorithm>();
-            facade_provider = std::make_unique<ImmutableProvider<Algorithm>>(config.storage_config);
+                                << algorithm::name<AlgorithmT>();
+            facade_provider =
+                std::make_unique<ImmutableProvider<AlgorithmT>>(config.storage_config);
         }
     }
 
@@ -86,7 +87,7 @@ template <typename Algorithm> class Engine final : public EngineInterface
                  util::json::Object &result) const override final
     {
         auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
+        auto algorithms = RoutingAlgorithms<AlgorithmT>{heaps, *facade};
         return route_plugin.HandleRequest(*facade, algorithms, params, result);
     }
 
@@ -94,7 +95,7 @@ template <typename Algorithm> class Engine final : public EngineInterface
                  util::json::Object &result) const override final
     {
         auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
+        auto algorithms = RoutingAlgorithms<AlgorithmT>{heaps, *facade};
         return table_plugin.HandleRequest(*facade, algorithms, params, result);
     }
 
@@ -102,14 +103,14 @@ template <typename Algorithm> class Engine final : public EngineInterface
                    util::json::Object &result) const override final
     {
         auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
+        auto algorithms = RoutingAlgorithms<AlgorithmT>{heaps, *facade};
         return nearest_plugin.HandleRequest(*facade, algorithms, params, result);
     }
 
     Status Trip(const api::TripParameters &params, util::json::Object &result) const override final
     {
         auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
+        auto algorithms = RoutingAlgorithms<AlgorithmT>{heaps, *facade};
         return trip_plugin.HandleRequest(*facade, algorithms, params, result);
     }
 
@@ -117,22 +118,22 @@ template <typename Algorithm> class Engine final : public EngineInterface
                  util::json::Object &result) const override final
     {
         auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
+        auto algorithms = RoutingAlgorithms<AlgorithmT>{heaps, *facade};
         return match_plugin.HandleRequest(*facade, algorithms, params, result);
     }
 
     Status Tile(const api::TileParameters &params, std::string &result) const override final
     {
         auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
+        auto algorithms = RoutingAlgorithms<AlgorithmT>{heaps, *facade};
         return tile_plugin.HandleRequest(*facade, algorithms, params, result);
     }
 
     static bool CheckCompability(const EngineConfig &config);
 
   private:
-    std::unique_ptr<DataFacadeProvider<Algorithm>> facade_provider;
-    mutable SearchEngineData<Algorithm> heaps;
+    std::unique_ptr<DataFacadeProvider<AlgorithmT>> facade_provider;
+    mutable SearchEngineData heaps;
 
     const plugins::ViaRoutePlugin route_plugin;
     const plugins::TablePlugin table_plugin;
@@ -142,8 +143,7 @@ template <typename Algorithm> class Engine final : public EngineInterface
     const plugins::TilePlugin tile_plugin;
 };
 
-template <>
-bool Engine<routing_algorithms::ch::Algorithm>::CheckCompability(const EngineConfig &config)
+template <> bool Engine<algorithm::CH>::CheckCompability(const EngineConfig &config)
 {
     if (config.use_shared_memory)
     {
@@ -168,10 +168,9 @@ bool Engine<routing_algorithms::ch::Algorithm>::CheckCompability(const EngineCon
     }
 }
 
-template <>
-bool Engine<routing_algorithms::corech::Algorithm>::CheckCompability(const EngineConfig &config)
+template <> bool Engine<algorithm::CoreCH>::CheckCompability(const EngineConfig &config)
 {
-    if (!Engine<routing_algorithms::ch::Algorithm>::CheckCompability(config))
+    if (!Engine<algorithm::CH>::CheckCompability(config))
     {
         return false;
     }

include/engine/routing_algorithms.hpp

@@ -54,11 +54,11 @@ class RoutingAlgorithmsInterface
 };
 
 // Short-lived object passed to each plugin in request to wrap routing algorithms
-template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgorithmsInterface
+template <typename AlgorithmT> class RoutingAlgorithms final : public RoutingAlgorithmsInterface
 {
   public:
-    RoutingAlgorithms(SearchEngineData<Algorithm> &heaps,
-                      const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade)
+    RoutingAlgorithms(SearchEngineData &heaps,
+                      const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &facade)
         : heaps(heaps), facade(facade)
     {
     }
@@ -93,49 +93,49 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
 
     bool HasAlternativePathSearch() const final override
     {
-        return routing_algorithms::HasAlternativePathSearch<Algorithm>::value;
+        return algorithm_trais::HasAlternativePathSearch<AlgorithmT>::value;
     }
 
     bool HasShortestPathSearch() const final override
     {
-        return routing_algorithms::HasShortestPathSearch<Algorithm>::value;
+        return algorithm_trais::HasShortestPathSearch<AlgorithmT>::value;
     }
 
     bool HasDirectShortestPathSearch() const final override
     {
-        return routing_algorithms::HasDirectShortestPathSearch<Algorithm>::value;
+        return algorithm_trais::HasDirectShortestPathSearch<AlgorithmT>::value;
     }
 
     bool HasMapMatching() const final override
     {
-        return routing_algorithms::HasMapMatching<Algorithm>::value;
+        return algorithm_trais::HasMapMatching<AlgorithmT>::value;
     }
 
     bool HasManyToManySearch() const final override
     {
-        return routing_algorithms::HasManyToManySearch<Algorithm>::value;
+        return algorithm_trais::HasManyToManySearch<AlgorithmT>::value;
     }
 
     bool HasGetTileTurns() const final override
     {
-        return routing_algorithms::HasGetTileTurns<Algorithm>::value;
+        return algorithm_trais::HasGetTileTurns<AlgorithmT>::value;
     }
 
   private:
-    SearchEngineData<Algorithm> &heaps;
+    SearchEngineData &heaps;
     // Owned by shared-ptr passed to the query
-    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade;
+    const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &facade;
 };
 
-template <typename Algorithm>
+template <typename AlgorithmT>
 InternalRouteResult
-RoutingAlgorithms<Algorithm>::AlternativePathSearch(const PhantomNodes &phantom_node_pair) const
+RoutingAlgorithms<AlgorithmT>::AlternativePathSearch(const PhantomNodes &phantom_node_pair) const
 {
-    return routing_algorithms::ch::alternativePathSearch(heaps, facade, phantom_node_pair);
+    return routing_algorithms::alternativePathSearch(heaps, facade, phantom_node_pair);
 }
 
-template <typename Algorithm>
-InternalRouteResult RoutingAlgorithms<Algorithm>::ShortestPathSearch(
+template <typename AlgorithmT>
+InternalRouteResult RoutingAlgorithms<AlgorithmT>::ShortestPathSearch(
     const std::vector<PhantomNodes> &phantom_node_pair,
     const boost::optional<bool> continue_straight_at_waypoint) const
 {
@@ -143,25 +143,25 @@ InternalRouteResult RoutingAlgorithms<Algorithm>::ShortestPathSearch(
         heaps, facade, phantom_node_pair, continue_straight_at_waypoint);
 }
 
-template <typename Algorithm>
+template <typename AlgorithmT>
 InternalRouteResult
-RoutingAlgorithms<Algorithm>::DirectShortestPathSearch(const PhantomNodes &phantom_nodes) const
+RoutingAlgorithms<AlgorithmT>::DirectShortestPathSearch(const PhantomNodes &phantom_nodes) const
 {
     return routing_algorithms::directShortestPathSearch(heaps, facade, phantom_nodes);
 }
 
-template <typename Algorithm>
-std::vector<EdgeWeight>
-RoutingAlgorithms<Algorithm>::ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
-                                               const std::vector<std::size_t> &source_indices,
-                                               const std::vector<std::size_t> &target_indices) const
+template <typename AlgorithmT>
+std::vector<EdgeWeight> RoutingAlgorithms<AlgorithmT>::ManyToManySearch(
+    const std::vector<PhantomNode> &phantom_nodes,
+    const std::vector<std::size_t> &source_indices,
+    const std::vector<std::size_t> &target_indices) const
 {
-    return routing_algorithms::ch::manyToManySearch(
+    return routing_algorithms::manyToManySearch(
         heaps, facade, phantom_nodes, source_indices, target_indices);
 }
 
-template <typename Algorithm>
-inline routing_algorithms::SubMatchingList RoutingAlgorithms<Algorithm>::MapMatching(
+template <typename AlgorithmT>
+inline routing_algorithms::SubMatchingList RoutingAlgorithms<AlgorithmT>::MapMatching(
     const routing_algorithms::CandidateLists &candidates_list,
     const std::vector<util::Coordinate> &trace_coordinates,
     const std::vector<unsigned> &trace_timestamps,
@@ -177,53 +177,52 @@ inline routing_algorithms::SubMatchingList RoutingAlgorithms<Algorithm>::MapMatc
                                            allow_splitting);
 }
 
-template <typename Algorithm>
-inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<Algorithm>::GetTileTurns(
+template <typename AlgorithmT>
+inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<AlgorithmT>::GetTileTurns(
     const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
     const std::vector<std::size_t> &sorted_edge_indexes) const
 {
     return routing_algorithms::getTileTurns(facade, edges, sorted_edge_indexes);
 }
 
-// CoreCH overrides
-template <>
-InternalRouteResult inline RoutingAlgorithms<
-    routing_algorithms::corech::Algorithm>::AlternativePathSearch(const PhantomNodes &) const
-{
-    throw util::exception("AlternativePathSearch is disabled due to performance reasons");
-}
-
-template <>
-inline std::vector<EdgeWeight>
-RoutingAlgorithms<routing_algorithms::corech::Algorithm>::ManyToManySearch(
-    const std::vector<PhantomNode> &,
-    const std::vector<std::size_t> &,
-    const std::vector<std::size_t> &) const
-{
-    throw util::exception("ManyToManySearch is disabled due to performance reasons");
-}
-
 // MLD overrides for not implemented
 template <>
-InternalRouteResult inline RoutingAlgorithms<
-    routing_algorithms::mld::Algorithm>::AlternativePathSearch(const PhantomNodes &) const
+InternalRouteResult inline RoutingAlgorithms<algorithm::MLD>::AlternativePathSearch(
+    const PhantomNodes &) const
 {
     throw util::exception("AlternativePathSearch is not implemented");
 }
 
+template <>
+inline InternalRouteResult
+RoutingAlgorithms<algorithm::MLD>::ShortestPathSearch(const std::vector<PhantomNodes> &,
+                                                      const boost::optional<bool>) const
+{
+    throw util::exception("ShortestPathSearch is not implemented");
+}
+
 template <>
 inline std::vector<EdgeWeight>
-RoutingAlgorithms<routing_algorithms::mld::Algorithm>::ManyToManySearch(
-    const std::vector<PhantomNode> &,
-    const std::vector<std::size_t> &,
-    const std::vector<std::size_t> &) const
+RoutingAlgorithms<algorithm::MLD>::ManyToManySearch(const std::vector<PhantomNode> &,
+                                                    const std::vector<std::size_t> &,
+                                                    const std::vector<std::size_t> &) const
 {
     throw util::exception("ManyToManySearch is not implemented");
 }
 
 template <>
-inline std::vector<routing_algorithms::TurnData>
-RoutingAlgorithms<routing_algorithms::mld::Algorithm>::GetTileTurns(
+inline routing_algorithms::SubMatchingList
+RoutingAlgorithms<algorithm::MLD>::MapMatching(const routing_algorithms::CandidateLists &,
+                                               const std::vector<util::Coordinate> &,
+                                               const std::vector<unsigned> &,
+                                               const std::vector<boost::optional<double>> &,
+                                               const bool) const
+{
+    throw util::exception("MapMatching is not implemented");
+}
+
+template <>
+inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<algorithm::MLD>::GetTileTurns(
     const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &,
     const std::vector<std::size_t> &) const
 {

include/engine/routing_algorithms/alternative_path.hpp

@@ -15,13 +15,12 @@ namespace engine
 {
 namespace routing_algorithms
 {
-namespace ch
-{
+
 InternalRouteResult
-alternativePathSearch(SearchEngineData<Algorithm> &search_engine_data,
-                      const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+alternativePathSearch(SearchEngineData &search_engine_data,
+                      const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                       const PhantomNodes &phantom_node_pair);
-} // namespace ch
+
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm

include/engine/routing_algorithms/direct_shortest_path.hpp

@@ -21,17 +21,12 @@ namespace routing_algorithms
 /// by the previous route.
 /// This variation is only an optimazation for graphs with slow queries, for example
 /// not fully contracted graphs.
-template <typename Algorithm>
+template <typename AlgorithmT>
 InternalRouteResult
-directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                         const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+directShortestPathSearch(SearchEngineData &engine_working_data,
+                         const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &facade,
                          const PhantomNodes &phantom_nodes);
 
-InternalRouteResult directShortestPathSearch(
-    SearchEngineData<mld::Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-    const PhantomNodes &phantom_nodes);
-
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm

include/engine/routing_algorithms/many_to_many.hpp

@@ -13,18 +13,16 @@ namespace osrm
 {
 namespace engine
 {
+
 namespace routing_algorithms
 {
 
-namespace ch
-{
 std::vector<EdgeWeight>
-manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
-                 const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+manyToManySearch(SearchEngineData &engine_working_data,
+                 const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                  const std::vector<PhantomNode> &phantom_nodes,
                  const std::vector<std::size_t> &source_indices,
                  const std::vector<std::size_t> &target_indices);
-} // namespace ch
 
 } // namespace routing_algorithms
 } // namespace engine

include/engine/routing_algorithms/map_matching.hpp

@@ -22,17 +22,25 @@ static const constexpr double DEFAULT_GPS_PRECISION = 5;
 
 //[1] "Hidden Markov Map Matching Through Noise and Sparseness";
 //     P. Newson and J. Krumm; 2009; ACM GIS
-template <typename Algorithm>
-SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
-                            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                            const CandidateLists &candidates_list,
-                            const std::vector<util::Coordinate> &trace_coordinates,
-                            const std::vector<unsigned> &trace_timestamps,
-                            const std::vector<boost::optional<double>> &trace_gps_precision,
-                            const bool allow_splitting);
+SubMatchingList
+mapMatching(SearchEngineData &engine_working_data,
+            const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+            const CandidateLists &candidates_list,
+            const std::vector<util::Coordinate> &trace_coordinates,
+            const std::vector<unsigned> &trace_timestamps,
+            const std::vector<boost::optional<double>> &trace_gps_precision,
+            const bool allow_splitting);
 
-} // namespace routing_algorithms
-} // namespace engine
-} // namespace osrm
+SubMatchingList
+mapMatching(SearchEngineData &engine_working_data,
+            const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
+            const CandidateLists &candidates_list,
+            const std::vector<util::Coordinate> &trace_coordinates,
+            const std::vector<unsigned> &trace_timestamps,
+            const std::vector<boost::optional<double>> &trace_gps_precision,
+            const bool allow_splitting);
+}
+}
+}
 
 #endif /* MAP_MATCHING_HPP */

include/engine/routing_algorithms/routing_base.hpp

@@ -37,10 +37,6 @@ static constexpr bool FORWARD_DIRECTION = true;
 static constexpr bool REVERSE_DIRECTION = false;
 static constexpr bool DO_NOT_FORCE_LOOPS = false;
 
-bool needsLoopForward(const PhantomNode &source_phantom, const PhantomNode &target_phantom);
-
-bool needsLoopBackwards(const PhantomNode &source_phantom, const PhantomNode &target_phantom);
-
 template <bool DIRECTION, typename Heap>
 void insertNodesInHeap(Heap &heap, const PhantomNode &phantom_node)
 {
@@ -62,8 +58,7 @@ void insertNodesInHeap(Heap &heap, const PhantomNode &phantom_node)
 }
 
 template <bool DIRECTION>
-void insertNodesInHeap(SearchEngineData<ch::Algorithm>::ManyToManyQueryHeap &heap,
-                       const PhantomNode &phantom_node)
+void insertNodesInHeap(SearchEngineData::ManyToManyQueryHeap &heap, const PhantomNode &phantom_node)
 {
     BOOST_ASSERT(phantom_node.IsValid());
 
@@ -174,7 +169,7 @@ void annotatePath(const FacadeT &facade,
                                              util::guidance::TurnBearing(0)});
         }
         BOOST_ASSERT(unpacked_path.size() > 0);
-        if (facade.HasLaneData(turn_id))
+        if (facade.hasLaneData(turn_id))
             unpacked_path.back().lane_data = facade.GetLaneData(turn_id);
 
         unpacked_path.back().entry_classid = facade.GetEntryClassID(turn_id);
@@ -310,57 +305,6 @@ void annotatePath(const FacadeT &facade,
     }
 }
 
-template <typename Algorithm>
-double getPathDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                       const std::vector<PathData> unpacked_path,
-                       const PhantomNode &source_phantom,
-                       const PhantomNode &target_phantom)
-{
-    using util::coordinate_calculation::detail::DEGREE_TO_RAD;
-    using util::coordinate_calculation::detail::EARTH_RADIUS;
-
-    double distance = 0;
-    double prev_lat = static_cast<double>(toFloating(source_phantom.location.lat)) * DEGREE_TO_RAD;
-    double prev_lon = static_cast<double>(toFloating(source_phantom.location.lon)) * DEGREE_TO_RAD;
-    double prev_cos = std::cos(prev_lat);
-    for (const auto &p : unpacked_path)
-    {
-        const auto current_coordinate = facade.GetCoordinateOfNode(p.turn_via_node);
-
-        const double current_lat =
-            static_cast<double>(toFloating(current_coordinate.lat)) * DEGREE_TO_RAD;
-        const double current_lon =
-            static_cast<double>(toFloating(current_coordinate.lon)) * DEGREE_TO_RAD;
-        const double current_cos = std::cos(current_lat);
-
-        const double sin_dlon = std::sin((prev_lon - current_lon) / 2.0);
-        const double sin_dlat = std::sin((prev_lat - current_lat) / 2.0);
-
-        const double aharv = sin_dlat * sin_dlat + prev_cos * current_cos * sin_dlon * sin_dlon;
-        const double charv = 2. * std::atan2(std::sqrt(aharv), std::sqrt(1.0 - aharv));
-        distance += EARTH_RADIUS * charv;
-
-        prev_lat = current_lat;
-        prev_lon = current_lon;
-        prev_cos = current_cos;
-    }
-
-    const double current_lat =
-        static_cast<double>(toFloating(target_phantom.location.lat)) * DEGREE_TO_RAD;
-    const double current_lon =
-        static_cast<double>(toFloating(target_phantom.location.lon)) * DEGREE_TO_RAD;
-    const double current_cos = std::cos(current_lat);
-
-    const double sin_dlon = std::sin((prev_lon - current_lon) / 2.0);
-    const double sin_dlat = std::sin((prev_lat - current_lat) / 2.0);
-
-    const double aharv = sin_dlat * sin_dlat + prev_cos * current_cos * sin_dlon * sin_dlon;
-    const double charv = 2. * std::atan2(std::sqrt(aharv), std::sqrt(1.0 - aharv));
-    distance += EARTH_RADIUS * charv;
-
-    return distance;
-}
-
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm

include/engine/routing_algorithms/routing_base_ch.hpp

@@ -23,7 +23,7 @@ namespace ch
 
 // Stalling
 template <bool DIRECTION, typename HeapT>
-bool stallAtNode(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+bool stallAtNode(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                  const NodeID node,
                  const EdgeWeight weight,
                  const HeapT &query_heap)
@@ -49,10 +49,10 @@ bool stallAtNode(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
 }
 
 template <bool DIRECTION>
-void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
-                        SearchEngineData<Algorithm>::QueryHeap &heap)
+                        SearchEngineData::QueryHeap &heap)
 {
     for (const auto edge : facade.GetAdjacentEdgeRange(node))
     {
@@ -113,9 +113,9 @@ we need to add an offset to the termination criterion.
 static constexpr bool ENABLE_STALLING = true;
 static constexpr bool DISABLE_STALLING = false;
 template <bool DIRECTION, bool STALLING = ENABLE_STALLING>
-void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                 SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                 SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                 SearchEngineData::QueryHeap &forward_heap,
+                 SearchEngineData::QueryHeap &reverse_heap,
                  NodeID &middle_node_id,
                  EdgeWeight &upper_bound,
                  EdgeWeight min_edge_offset,
@@ -186,8 +186,9 @@ void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
 }
 
 template <bool UseDuration>
-EdgeWeight getLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                         NodeID node)
+EdgeWeight
+getLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+              NodeID node)
 {
     EdgeWeight loop_weight = UseDuration ? MAXIMAL_EDGE_DURATION : INVALID_EDGE_WEIGHT;
     for (auto edge : facade.GetAdjacentEdgeRange(node))
@@ -227,7 +228,7 @@ EdgeWeight getLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<Al
  * original edge found.
  */
 template <typename BidirectionalIterator, typename Callback>
-void unpackPath(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void unpackPath(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                 BidirectionalIterator packed_path_begin,
                 BidirectionalIterator packed_path_end,
                 Callback &&callback)
@@ -324,17 +325,17 @@ void unpackPath(const FacadeT &facade,
  * @param to the node the CH edge finishes at
  * @param unpacked_path the sequence of original NodeIDs that make up the expanded CH edge
  */
-void unpackEdge(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void unpackEdge(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                 const NodeID from,
                 const NodeID to,
                 std::vector<NodeID> &unpacked_path);
 
-void retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                                const SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+void retrievePackedPathFromHeap(const SearchEngineData::QueryHeap &forward_heap,
+                                const SearchEngineData::QueryHeap &reverse_heap,
                                 const NodeID middle_node_id,
                                 std::vector<NodeID> &packed_path);
 
-void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHeap &search_heap,
+void retrievePackedPathFromSingleHeap(const SearchEngineData::QueryHeap &search_heap,
                                       const NodeID middle_node_id,
                                       std::vector<NodeID> &packed_path);
 
@@ -350,9 +351,9 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHe
 // && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
-void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-            SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-            SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+void search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+            SearchEngineData::QueryHeap &forward_heap,
+            SearchEngineData::QueryHeap &reverse_heap,
             std::int32_t &weight,
             std::vector<NodeID> &packed_leg,
             const bool force_loop_forward,
@@ -360,16 +361,15 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &fac
             const int duration_upper_bound = INVALID_EDGE_WEIGHT);
 
 // Alias to be compatible with the overload for CoreCH that needs 4 heaps
-inline void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   EdgeWeight &weight,
+inline void search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                   SearchEngineData::QueryHeap &forward_heap,
+                   SearchEngineData::QueryHeap &reverse_heap,
+                   SearchEngineData::QueryHeap &,
+                   SearchEngineData::QueryHeap &,
+                   std::int32_t &weight,
                    std::vector<NodeID> &packed_leg,
                    const bool force_loop_forward,
                    const bool force_loop_reverse,
-                   const PhantomNodes & /*phantom_nodes*/,
                    const int duration_upper_bound = INVALID_EDGE_WEIGHT)
 {
     search(facade,
@@ -382,35 +382,6 @@ inline void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorith
            duration_upper_bound);
 }
 
-// Requires the heaps for be empty
-// If heaps should be adjusted to be initialized outside of this function,
-// the addition of force_loop parameters might be required
-double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   int duration_upper_bound = INVALID_EDGE_WEIGHT);
-
-// Alias to be compatible with the overload for CoreCH that needs 4 heaps
-inline double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   int duration_upper_bound = INVALID_EDGE_WEIGHT)
-{
-    return getNetworkDistance(
-        facade, forward_heap, reverse_heap, source_phantom, target_phantom, duration_upper_bound);
-}
-} // namespace ch
-
-namespace corech
-{
 // assumes that heaps are already setup correctly.
 // A forced loop might be necessary, if source and target are on the same segment.
 // If this is the case and the offsets of the respective direction are larger for the source
@@ -420,43 +391,66 @@ namespace corech
 // && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
-void search(const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
-            SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-            SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-            SearchEngineData<Algorithm>::QueryHeap &forward_core_heap,
-            SearchEngineData<Algorithm>::QueryHeap &reverse_core_heap,
+void search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
+            SearchEngineData::QueryHeap &forward_heap,
+            SearchEngineData::QueryHeap &reverse_heap,
+            SearchEngineData::QueryHeap &forward_core_heap,
+            SearchEngineData::QueryHeap &reverse_core_heap,
             int &weight,
             std::vector<NodeID> &packed_leg,
             const bool force_loop_forward,
             const bool force_loop_reverse,
-            const PhantomNodes &phantom_nodes,
             int duration_upper_bound = INVALID_EDGE_WEIGHT);
 
+bool needsLoopForward(const PhantomNode &source_phantom, const PhantomNode &target_phantom);
+
+bool needsLoopBackwards(const PhantomNode &source_phantom, const PhantomNode &target_phantom);
+
+double getPathDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                       const std::vector<NodeID> &packed_path,
+                       const PhantomNode &source_phantom,
+                       const PhantomNode &target_phantom);
+
 // Requires the heaps for be empty
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
 double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_core_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_core_heap,
+getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
+                   SearchEngineData::QueryHeap &forward_heap,
+                   SearchEngineData::QueryHeap &reverse_heap,
+                   SearchEngineData::QueryHeap &forward_core_heap,
+                   SearchEngineData::QueryHeap &reverse_core_heap,
                    const PhantomNode &source_phantom,
                    const PhantomNode &target_phantom,
                    int duration_upper_bound = INVALID_EDGE_WEIGHT);
 
-template <typename RandomIter, typename FacadeT>
-void unpackPath(const FacadeT &facade,
-                RandomIter packed_path_begin,
-                RandomIter packed_path_end,
-                const PhantomNodes &phantom_nodes,
-                std::vector<PathData> &unpacked_path)
+// Requires the heaps for be empty
+// If heaps should be adjusted to be initialized outside of this function,
+// the addition of force_loop parameters might be required
+double
+getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                   SearchEngineData::QueryHeap &forward_heap,
+                   SearchEngineData::QueryHeap &reverse_heap,
+                   const PhantomNode &source_phantom,
+                   const PhantomNode &target_phantom,
+                   int duration_upper_bound = INVALID_EDGE_WEIGHT);
+
+// Alias to be compatible with the overload for CoreCH that needs 4 heaps
+inline double
+getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                   SearchEngineData::QueryHeap &forward_heap,
+                   SearchEngineData::QueryHeap &reverse_heap,
+                   SearchEngineData::QueryHeap &,
+                   SearchEngineData::QueryHeap &,
+                   const PhantomNode &source_phantom,
+                   const PhantomNode &target_phantom,
+                   int duration_upper_bound = INVALID_EDGE_WEIGHT)
 {
-    return ch::unpackPath(facade, packed_path_begin, packed_path_end, phantom_nodes, unpacked_path);
+    return getNetworkDistance(
+        facade, forward_heap, reverse_heap, source_phantom, target_phantom, duration_upper_bound);
 }
 
-} // namespace corech
-
+} // namespace ch
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -24,9 +24,9 @@ namespace
 // Unrestricted search (Args is const PhantomNodes &):
 //   * use partition.GetQueryLevel to find the node query level based on source and target phantoms
 //   * allow to traverse all cells
-inline LevelID getNodeQureyLevel(const partition::MultiLevelPartitionView &partition,
-                                 NodeID node,
-                                 const PhantomNodes &phantom_nodes)
+LevelID getNodeQureyLevel(const partition::MultiLevelPartitionView &partition,
+                          NodeID node,
+                          const PhantomNodes &phantom_nodes)
 {
     auto level = [&partition, node](const SegmentID &source, const SegmentID &target) {
         if (source.enabled && target.enabled)
@@ -43,31 +43,25 @@ inline LevelID getNodeQureyLevel(const partition::MultiLevelPartitionView &parti
                                    phantom_nodes.target_phantom.reverse_segment_id)));
 }
 
-inline bool checkParentCellRestriction(CellID, const PhantomNodes &) { return true; }
+bool checkParentCellRestriction(CellID, const PhantomNodes &) { return true; }
 
 // Restricted search (Args is LevelID, CellID):
 //   * use the fixed level for queries
 //   * check if the node cell is the same as the specified parent onr
-inline LevelID
-getNodeQureyLevel(const partition::MultiLevelPartitionView &, NodeID, LevelID level, CellID)
+LevelID getNodeQureyLevel(const partition::MultiLevelPartitionView &, NodeID, LevelID level, CellID)
 {
     return level;
 }
 
-inline bool checkParentCellRestriction(CellID cell, LevelID, CellID parent)
-{
-    return cell == parent;
-}
+bool checkParentCellRestriction(CellID cell, LevelID, CellID parent) { return cell == parent; }
 }
 
 template <bool DIRECTION, typename... Args>
-void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                 SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                 SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::MLD> &facade,
+                 SearchEngineData::MultiLayerDijkstraHeap &forward_heap,
+                 SearchEngineData::MultiLayerDijkstraHeap &reverse_heap,
                  NodeID &middle_node,
                  EdgeWeight &path_upper_bound,
-                 const bool force_loop_forward,
-                 const bool force_loop_reverse,
                  Args... args)
 {
     const auto &partition = facade.GetMultiLevelPartition();
@@ -85,11 +79,7 @@ void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
     {
         auto reverse_weight = reverse_heap.GetKey(node);
         auto path_weight = weight + reverse_weight;
-
-        // if loops are forced, they are so at the source
-        if (!(force_loop_forward && forward_heap.GetData(node).parent == node) &&
-            !(force_loop_reverse && reverse_heap.GetData(node).parent == node) &&
-            (path_weight >= 0) && (path_weight < path_upper_bound))
+        if (path_weight >= 0 && path_weight < path_upper_bound)
         {
             middle_node = node;
             path_upper_bound = path_weight;
@@ -181,11 +171,9 @@ void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
 
 template <typename... Args>
 std::tuple<EdgeWeight, NodeID, NodeID, std::vector<EdgeID>>
-search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-       SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-       SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-       const bool force_loop_forward,
-       const bool force_loop_reverse,
+search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::MLD> &facade,
+       SearchEngineData::MultiLayerDijkstraHeap &forward_heap,
+       SearchEngineData::MultiLayerDijkstraHeap &reverse_heap,
        Args... args)
 {
 
@@ -204,27 +192,15 @@ search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
     {
         if (!forward_heap.Empty())
         {
-            routingStep<FORWARD_DIRECTION>(facade,
-                                           forward_heap,
-                                           reverse_heap,
-                                           middle,
-                                           weight,
-                                           force_loop_forward,
-                                           force_loop_reverse,
-                                           args...);
+            routingStep<FORWARD_DIRECTION>(
+                facade, forward_heap, reverse_heap, middle, weight, args...);
             if (!forward_heap.Empty())
                 forward_heap_min = forward_heap.MinKey();
         }
         if (!reverse_heap.Empty())
         {
-            routingStep<REVERSE_DIRECTION>(facade,
-                                           reverse_heap,
-                                           forward_heap,
-                                           middle,
-                                           weight,
-                                           force_loop_reverse,
-                                           force_loop_forward,
-                                           args...);
+            routingStep<REVERSE_DIRECTION>(
+                facade, reverse_heap, forward_heap, middle, weight, args...);
             if (!reverse_heap.Empty())
                 reverse_heap_min = reverse_heap.MinKey();
         }
@@ -292,13 +268,7 @@ search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
             NodeID subpath_source, subpath_target;
             std::vector<EdgeID> subpath;
             std::tie(subpath_weight, subpath_source, subpath_target, subpath) =
-                search(facade,
-                       forward_heap,
-                       reverse_heap,
-                       force_loop_forward,
-                       force_loop_reverse,
-                       sublevel,
-                       parent_cell_id);
+                search(facade, forward_heap, reverse_heap, sublevel, parent_cell_id);
             BOOST_ASSERT(!subpath.empty());
             BOOST_ASSERT(subpath_source == source);
             BOOST_ASSERT(subpath_target == target);
@@ -309,94 +279,6 @@ search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
     return std::make_tuple(weight, source_node, target_node, std::move(unpacked_path));
 }
 
-// Alias to be compatible with the overload for CoreCH that needs 4 heaps for shortest path search
-inline void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   EdgeWeight &weight,
-                   std::vector<NodeID> &packed_leg,
-                   const bool force_loop_forward,
-                   const bool force_loop_reverse,
-                   const PhantomNodes &phantom_nodes,
-                   const int duration_upper_bound = INVALID_EDGE_WEIGHT)
-{
-    (void)duration_upper_bound; // TODO: limiting search radius is not implemented for MLD
-
-    NodeID source_node, target_node;
-    std::vector<EdgeID> unpacked_edges;
-    std::tie(weight, source_node, target_node, unpacked_edges) = mld::search(
-        facade, forward_heap, reverse_heap, force_loop_forward, force_loop_reverse, phantom_nodes);
-
-    if (weight != INVALID_EDGE_WEIGHT)
-    {
-        packed_leg.push_back(source_node);
-        std::transform(unpacked_edges.begin(),
-                       unpacked_edges.end(),
-                       std::back_inserter(packed_leg),
-                       [&facade](const auto edge) { return facade.GetTarget(edge); });
-    }
-}
-
-template <typename RandomIter, typename FacadeT>
-void unpackPath(const FacadeT &facade,
-                RandomIter packed_path_begin,
-                RandomIter packed_path_end,
-                const PhantomNodes &phantom_nodes,
-                std::vector<PathData> &unpacked_path)
-{
-    const auto nodes_number = std::distance(packed_path_begin, packed_path_end);
-    BOOST_ASSERT(nodes_number > 0);
-
-    std::vector<EdgeID> unpacked_edges;
-
-    auto source_node = *packed_path_begin, target_node = *packed_path_begin;
-
-    if (nodes_number > 1)
-    {
-        target_node = *std::prev(packed_path_end);
-        util::for_each_pair(packed_path_begin,
-                            packed_path_end,
-                            [&facade, &unpacked_edges](const auto from, const auto to) {
-                                unpacked_edges.push_back(facade.FindEdge(from, to));
-                            });
-    }
-
-    annotatePath(facade, source_node, target_node, unpacked_edges, phantom_nodes, unpacked_path);
-}
-
-inline double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   SearchEngineData<Algorithm>::QueryHeap & /*forward_core_heap*/,
-                   SearchEngineData<Algorithm>::QueryHeap & /*reverse_core_heap*/,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   int /*duration_upper_bound*/)
-{
-    forward_heap.Clear();
-    reverse_heap.Clear();
-
-    const PhantomNodes phantom_nodes{source_phantom, target_phantom};
-    insertNodesInHeaps(forward_heap, reverse_heap, phantom_nodes);
-
-    EdgeWeight weight;
-    NodeID source_node, target_node;
-    std::vector<EdgeID> unpacked_edges;
-    std::tie(weight, source_node, target_node, unpacked_edges) = search(
-        facade, forward_heap, reverse_heap, DO_NOT_FORCE_LOOPS, DO_NOT_FORCE_LOOPS, phantom_nodes);
-
-    if (weight == INVALID_EDGE_WEIGHT)
-        return std::numeric_limits<double>::max();
-
-    std::vector<PathData> unpacked_path;
-    annotatePath(facade, source_node, target_node, unpacked_edges, phantom_nodes, unpacked_path);
-
-    return getPathDistance(facade, unpacked_path, source_phantom, target_phantom);
-}
-
 } // namespace mld
 } // namespace routing_algorithms
 } // namespace engine

include/engine/routing_algorithms/shortest_path.hpp

@@ -13,10 +13,15 @@ namespace engine
 namespace routing_algorithms
 {
 
-template <typename Algorithm>
 InternalRouteResult
-shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+shortestPathSearch(SearchEngineData &engine_working_data,
+                   const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                   const std::vector<PhantomNodes> &phantom_nodes_vector,
+                   const boost::optional<bool> continue_straight_at_waypoint);
+
+InternalRouteResult
+shortestPathSearch(SearchEngineData &engine_working_data,
+                   const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
                    const boost::optional<bool> continue_straight_at_waypoint);
 

include/engine/routing_algorithms/tile_turns.hpp

@@ -29,7 +29,7 @@ struct TurnData final
 using RTreeLeaf = datafacade::BaseDataFacade::RTreeLeaf;
 
 std::vector<TurnData>
-getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
              const std::vector<RTreeLeaf> &edges,
              const std::vector<std::size_t> &sorted_edge_indexes);
 

include/engine/search_engine_data.hpp

@@ -3,7 +3,7 @@
 
 #include <boost/thread/tss.hpp>
 
-#include "engine/algorithm.hpp"
+#include "partition/multi_level_partition.hpp"
 #include "util/binary_heap.hpp"
 #include "util/typedefs.hpp"
 
@@ -24,7 +24,14 @@ struct ManyToManyHeapData : HeapData
     ManyToManyHeapData(NodeID p, EdgeWeight duration) : HeapData(p), duration(duration) {}
 };
 
-template <typename Algorithm> struct SearchEngineData
+struct MultiLayerDijkstraHeapData : HeapData
+{
+    bool from_clique_arc;
+    MultiLayerDijkstraHeapData(NodeID p) : HeapData(p), from_clique_arc(false) {}
+    MultiLayerDijkstraHeapData(NodeID p, bool from) : HeapData(p), from_clique_arc(from) {}
+};
+
+struct SearchEngineData
 {
     using QueryHeap = util::
         BinaryHeap<NodeID, NodeID, EdgeWeight, HeapData, util::UnorderedMapStorage<NodeID, int>>;
@@ -38,6 +45,14 @@ template <typename Algorithm> struct SearchEngineData
 
     using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
 
+    using MultiLayerDijkstraHeap = util::BinaryHeap<NodeID,
+                                                    NodeID,
+                                                    EdgeWeight,
+                                                    MultiLayerDijkstraHeapData,
+                                                    util::UnorderedMapStorage<NodeID, int>>;
+
+    using MultiLayerDijkstraHeapPtr = boost::thread_specific_ptr<MultiLayerDijkstraHeap>;
+
     static SearchEngineHeapPtr forward_heap_1;
     static SearchEngineHeapPtr reverse_heap_1;
     static SearchEngineHeapPtr forward_heap_2;
@@ -45,42 +60,18 @@ template <typename Algorithm> struct SearchEngineData
     static SearchEngineHeapPtr forward_heap_3;
     static SearchEngineHeapPtr reverse_heap_3;
     static ManyToManyHeapPtr many_to_many_heap;
+    static MultiLayerDijkstraHeapPtr mld_forward_heap;
+    static MultiLayerDijkstraHeapPtr mld_reverse_heap;
 
-    void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes);
+    void InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes);
 
-    void InitializeOrClearSecondThreadLocalStorage(unsigned number_of_nodes);
+    void InitializeOrClearSecondThreadLocalStorage(const unsigned number_of_nodes);
 
-    void InitializeOrClearThirdThreadLocalStorage(unsigned number_of_nodes);
+    void InitializeOrClearThirdThreadLocalStorage(const unsigned number_of_nodes);
 
-    void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes);
-};
+    void InitializeOrClearManyToManyThreadLocalStorage(const unsigned number_of_nodes);
 
-struct MultiLayerDijkstraHeapData
-{
-    NodeID parent;
-    bool from_clique_arc;
-    MultiLayerDijkstraHeapData(NodeID p) : parent(p), from_clique_arc(false) {}
-    MultiLayerDijkstraHeapData(NodeID p, bool from) : parent(p), from_clique_arc(from) {}
-};
-
-template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
-{
-    using QueryHeap = util::BinaryHeap<NodeID,
-                                       NodeID,
-                                       EdgeWeight,
-                                       MultiLayerDijkstraHeapData,
-                                       util::UnorderedMapStorage<NodeID, int>>;
-
-    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
-
-    static SearchEngineHeapPtr forward_heap_1;
-    static SearchEngineHeapPtr reverse_heap_1;
-    static SearchEngineHeapPtr forward_heap_2;
-    static SearchEngineHeapPtr reverse_heap_2;
-
-    void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes);
-
-    void InitializeOrClearSecondThreadLocalStorage(unsigned number_of_nodes);
+    void InitializeOrClearMultiLayerDijkstraThreadLocalStorage(const unsigned number_of_nodes);
 };
 }
 }

include/extractor/edge_based_graph_factory.hpp

@@ -21,7 +21,6 @@
 #include "util/guidance/entry_class.hpp"
 #include "util/name_table.hpp"
 #include "util/node_based_graph.hpp"
-#include "util/packed_vector.hpp"
 #include "util/typedefs.hpp"
 
 #include "storage/io.hpp"
@@ -73,8 +72,7 @@ class EdgeBasedGraphFactory
                                    const std::unordered_set<NodeID> &barrier_nodes,
                                    const std::unordered_set<NodeID> &traffic_lights,
                                    std::shared_ptr<const RestrictionMap> restriction_map,
-                                   const std::vector<util::Coordinate> &coordinates,
-                                   const util::PackedVector<OSMNodeID> &osm_node_ids,
+                                   const std::vector<QueryNode> &node_info_list,
                                    ProfileProperties profile_properties,
                                    const util::NameTable &name_table,
                                    std::vector<std::uint32_t> &turn_lane_offsets,
@@ -130,8 +128,7 @@ class EdgeBasedGraphFactory
     util::DeallocatingVector<EdgeBasedEdge> m_edge_based_edge_list;
     EdgeID m_max_edge_id;
 
-    const std::vector<util::Coordinate> &m_coordinates;
-    const util::PackedVector<OSMNodeID> &m_osm_node_ids;
+    const std::vector<QueryNode> &m_node_info_list;
     std::shared_ptr<util::NodeBasedDynamicGraph> m_node_based_graph;
     std::shared_ptr<RestrictionMap const> m_restriction_map;
 

include/extractor/extraction_way.hpp

@@ -62,6 +62,13 @@ struct ExtractionWay
         forward_restricted = false;
     }
 
+    // These accessors exists because it's not possible to take the address of a bitfield,
+    // and LUA therefore cannot read/write the mode attributes directly.
+    void set_forward_mode(const TravelMode m) { forward_travel_mode = m; }
+    TravelMode get_forward_mode() const { return forward_travel_mode; }
+    void set_backward_mode(const TravelMode m) { backward_travel_mode = m; }
+    TravelMode get_backward_mode() const { return backward_travel_mode; }
+
     // wrappers to allow assigning nil (nullptr) to string values
     void SetName(const char *value) { detail::maybeSetString(name, value); }
     const char *GetName() const { return name.c_str(); }
@@ -98,14 +105,14 @@ struct ExtractionWay
     std::string destinations;
     std::string turn_lanes_forward;
     std::string turn_lanes_backward;
-    guidance::RoadClassification road_classification;
+    bool roundabout;
+    bool circular;
+    bool is_startpoint;
+    bool backward_restricted;
+    bool forward_restricted;
     TravelMode forward_travel_mode : 4;
     TravelMode backward_travel_mode : 4;
-    bool roundabout : 1;
-    bool circular : 1;
-    bool is_startpoint : 1;
-    bool forward_restricted : 1;
-    bool backward_restricted : 1;
+    guidance::RoadClassification road_classification;
 };
 }
 }

include/extractor/extractor.hpp

@@ -58,8 +58,7 @@ class Extractor
 
     std::pair<std::size_t, EdgeID>
     BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
-                           std::vector<util::Coordinate> &coordinates,
-                           util::PackedVector<OSMNodeID> &osm_node_ids,
+                           std::vector<QueryNode> &internal_to_external_node_map,
                            std::vector<EdgeBasedNode> &node_based_edge_list,
                            std::vector<bool> &node_is_startpoint,
                            std::vector<EdgeWeight> &edge_based_node_weights,
@@ -67,18 +66,18 @@ class Extractor
                            const std::string &intersection_class_output_file);
     void WriteProfileProperties(const std::string &output_path,
                                 const ProfileProperties &properties) const;
+    void WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map);
     void FindComponents(unsigned max_edge_id,
                         const util::DeallocatingVector<EdgeBasedEdge> &edges,
                         std::vector<EdgeBasedNode> &nodes) const;
     void BuildRTree(std::vector<EdgeBasedNode> node_based_edge_list,
                     std::vector<bool> node_is_startpoint,
-                    const std::vector<util::Coordinate> &coordinates);
+                    const std::vector<QueryNode> &internal_to_external_node_map);
     std::shared_ptr<RestrictionMap> LoadRestrictionMap();
     std::shared_ptr<util::NodeBasedDynamicGraph>
     LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
                        std::unordered_set<NodeID> &traffic_lights,
-                       std::vector<util::Coordinate> &coordinates,
-                       util::PackedVector<OSMNodeID> &osm_node_ids);
+                       std::vector<QueryNode> &internal_to_external_node_map);
 
     void WriteEdgeBasedGraph(const std::string &output_file_filename,
                              const EdgeID max_edge_id,
@@ -95,7 +94,7 @@ class Extractor
     // Writes compressed node based graph and its embedding into a file for osrm-partition to use.
     static void WriteCompressedNodeBasedGraph(const std::string &path,
                                               const util::NodeBasedDynamicGraph &graph,
-                                              const std::vector<util::Coordinate> &coordiantes);
+                                              const std::vector<QueryNode> &externals);
 
     // globals persisting during the extraction process and the graph generation process
 

include/extractor/extractor_callbacks.hpp

@@ -63,7 +63,6 @@ class ExtractorCallbacks
     guidance::LaneDescriptionMap lane_description_map;
     ExtractionContainers &external_memory;
     bool fallback_to_duration;
-    bool force_split_edges;
 
   public:
     explicit ExtractorCallbacks(ExtractionContainers &extraction_containers,

include/extractor/files.hpp

@@ -1,180 +0,0 @@
-#ifndef OSRM_EXTRACTOR_FILES_HPP
-#define OSRM_EXTRACTOR_FILES_HPP
-
-#include "extractor/guidance/turn_lane_types.hpp"
-#include "extractor/serialization.hpp"
-
-#include "util/coordinate.hpp"
-#include "util/packed_vector.hpp"
-#include "util/serialization.hpp"
-
-#include <boost/assert.hpp>
-
-namespace osrm
-{
-namespace extractor
-{
-namespace files
-{
-
-// reads .osrm.nodes
-template <typename CoordinatesT, typename PackedOSMIDsT>
-inline void readNodes(const boost::filesystem::path &path,
-                      CoordinatesT &coordinates,
-                      PackedOSMIDsT &osm_node_ids)
-{
-    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
-    static_assert(std::is_same<typename PackedOSMIDsT::value_type, OSMNodeID>::value, "");
-
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    storage::serialization::read(reader, coordinates);
-    util::serialization::read(reader, osm_node_ids);
-}
-
-// writes .osrm.nodes
-template <typename CoordinatesT, typename PackedOSMIDsT>
-inline void writeNodes(const boost::filesystem::path &path,
-                       const CoordinatesT &coordinates,
-                       const PackedOSMIDsT &osm_node_ids)
-{
-    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
-    static_assert(std::is_same<typename PackedOSMIDsT::value_type, OSMNodeID>::value, "");
-
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    storage::serialization::write(writer, coordinates);
-    util::serialization::write(writer, osm_node_ids);
-}
-
-// reads .osrm.cnbg_to_ebg
-inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGToEBG> &mapping)
-{
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    storage::serialization::read(reader, mapping);
-}
-
-// writes .osrm.cnbg_to_ebg
-inline void writeNBGMapping(const boost::filesystem::path &path,
-                            const std::vector<NBGToEBG> &mapping)
-{
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    storage::serialization::write(writer, mapping);
-}
-
-// reads .osrm.datasource_names
-inline void readDatasources(const boost::filesystem::path &path, Datasources &sources)
-{
-    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    serialization::read(reader, sources);
-}
-
-// writes .osrm.datasource_names
-inline void writeDatasources(const boost::filesystem::path &path, Datasources &sources)
-{
-    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    serialization::write(writer, sources);
-}
-
-// reads .osrm.geometry
-template <typename SegmentDataT>
-inline void readSegmentData(const boost::filesystem::path &path, SegmentDataT &segment_data)
-{
-    static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
-                      std::is_same<SegmentDataView, SegmentDataT>::value,
-                  "");
-    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    serialization::read(reader, segment_data);
-}
-
-// writes .osrm.geometry
-template <typename SegmentDataT>
-inline void writeSegmentData(const boost::filesystem::path &path, const SegmentDataT &segment_data)
-{
-    static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
-                      std::is_same<SegmentDataView, SegmentDataT>::value,
-                  "");
-    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    serialization::write(writer, segment_data);
-}
-
-// reads .osrm.edges
-template <typename TurnDataT>
-inline void readTurnData(const boost::filesystem::path &path, TurnDataT &turn_data)
-{
-    static_assert(std::is_same<TurnDataContainer, TurnDataT>::value ||
-                      std::is_same<TurnDataView, TurnDataT>::value,
-                  "");
-    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    serialization::read(reader, turn_data);
-}
-
-// writes .osrm.edges
-template <typename TurnDataT>
-inline void writeTurnData(const boost::filesystem::path &path, const TurnDataT &turn_data)
-{
-    static_assert(std::is_same<TurnDataContainer, TurnDataT>::value ||
-                      std::is_same<TurnDataView, TurnDataT>::value,
-                  "");
-    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    serialization::write(writer, turn_data);
-}
-
-// reads .osrm.tls
-template <typename OffsetsT, typename MaskT>
-inline void readTurnLaneDescriptions(const boost::filesystem::path &path,
-                                     OffsetsT &turn_offsets,
-                                     MaskT &turn_masks)
-{
-    static_assert(
-        std::is_same<typename MaskT::value_type, extractor::guidance::TurnLaneType::Mask>::value,
-        "");
-    static_assert(std::is_same<typename OffsetsT::value_type, std::uint32_t>::value, "");
-
-    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    storage::serialization::read(reader, turn_offsets);
-    storage::serialization::read(reader, turn_masks);
-}
-
-// writes .osrm.tls
-template <typename OffsetsT, typename MaskT>
-inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
-                                      const OffsetsT &turn_offsets,
-                                      const MaskT &turn_masks)
-{
-    static_assert(
-        std::is_same<typename MaskT::value_type, extractor::guidance::TurnLaneType::Mask>::value,
-        "");
-    static_assert(std::is_same<typename OffsetsT::value_type, std::uint32_t>::value, "");
-
-    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    storage::serialization::write(writer, turn_offsets);
-    storage::serialization::write(writer, turn_masks);
-}
-}
-}
-}
-
-#endif

include/extractor/guidance/coordinate_extractor.hpp

@@ -23,7 +23,7 @@ class CoordinateExtractor
   public:
     CoordinateExtractor(const util::NodeBasedDynamicGraph &node_based_graph,
                         const extractor::CompressedEdgeContainer &compressed_geometries,
-                        const std::vector<util::Coordinate> &node_coordinates);
+                        const std::vector<extractor::QueryNode> &node_coordinates);
 
     /* Find a interpolated coordinate a long the compressed geometries. The desired coordinate
      * should be in a certain distance. This method is dedicated to find representative coordinates
@@ -156,7 +156,7 @@ class CoordinateExtractor
   private:
     const util::NodeBasedDynamicGraph &node_based_graph;
     const extractor::CompressedEdgeContainer &compressed_geometries;
-    const std::vector<util::Coordinate> &node_coordinates;
+    const std::vector<extractor::QueryNode> &node_coordinates;
 
     double ComputeInterpolationFactor(const double desired_distance,
                                       const double distance_to_first,

include/extractor/guidance/intersection_generator.hpp

@@ -40,7 +40,7 @@ class IntersectionGenerator
     IntersectionGenerator(const util::NodeBasedDynamicGraph &node_based_graph,
                           const RestrictionMap &restriction_map,
                           const std::unordered_set<NodeID> &barrier_nodes,
-                          const std::vector<util::Coordinate> &coordinates,
+                          const std::vector<QueryNode> &node_info_list,
                           const CompressedEdgeContainer &compressed_edge_container);
 
     // For a source node `a` and a via edge `ab` creates an intersection at target `b`.
@@ -112,7 +112,7 @@ class IntersectionGenerator
     const util::NodeBasedDynamicGraph &node_based_graph;
     const RestrictionMap &restriction_map;
     const std::unordered_set<NodeID> &barrier_nodes;
-    const std::vector<util::Coordinate> &coordinates;
+    const std::vector<QueryNode> &node_info_list;
 
     // own state, used to find the correct coordinates along a road
     const CoordinateExtractor coordinate_extractor;

include/extractor/guidance/intersection_handler.hpp

@@ -34,7 +34,7 @@ class IntersectionHandler
 {
   public:
     IntersectionHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                        const std::vector<util::Coordinate> &coordinates,
+                        const std::vector<QueryNode> &node_info_list,
                         const util::NameTable &name_table,
                         const SuffixTable &street_name_suffix_table,
                         const IntersectionGenerator &intersection_generator);
@@ -51,7 +51,7 @@ class IntersectionHandler
 
   protected:
     const util::NodeBasedDynamicGraph &node_based_graph;
-    const std::vector<util::Coordinate> &coordinates;
+    const std::vector<QueryNode> &node_info_list;
     const util::NameTable &name_table;
     const SuffixTable &street_name_suffix_table;
     const IntersectionGenerator &intersection_generator;

include/extractor/guidance/intersection_normalizer.hpp

@@ -43,7 +43,7 @@ class IntersectionNormalizer
         std::vector<IntersectionNormalizationOperation> performed_merges;
     };
     IntersectionNormalizer(const util::NodeBasedDynamicGraph &node_based_graph,
-                           const std::vector<util::Coordinate> &node_coordinates,
+                           const std::vector<extractor::QueryNode> &node_coordinates,
                            const util::NameTable &name_table,
                            const SuffixTable &street_name_suffix_table,
                            const IntersectionGenerator &intersection_generator);

include/extractor/guidance/mergable_road_detector.hpp

@@ -2,7 +2,6 @@
 #define OSRM_EXTRACTOR_GUIDANCE_MERGEABLE_ROADS
 
 #include "extractor/guidance/intersection.hpp"
-#include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"
 
@@ -23,6 +22,7 @@ class NameTable;
 namespace extractor
 {
 
+struct QueryNode;
 class SuffixTable;
 
 namespace guidance
@@ -37,7 +37,7 @@ class MergableRoadDetector
     using MergableRoadData = IntersectionShapeData;
 
     MergableRoadDetector(const util::NodeBasedDynamicGraph &node_based_graph,
-                         const std::vector<util::Coordinate> &node_coordinates,
+                         const std::vector<QueryNode> &node_coordinates,
                          const IntersectionGenerator &intersection_generator,
                          const CoordinateExtractor &coordinate_extractor,
                          const util::NameTable &name_table,
@@ -138,7 +138,7 @@ class MergableRoadDetector
     bool IsLinkRoad(const NodeID intersection_node, const MergableRoadData &road) const;
 
     const util::NodeBasedDynamicGraph &node_based_graph;
-    const std::vector<util::Coordinate> &node_coordinates;
+    const std::vector<QueryNode> &node_coordinates;
     const IntersectionGenerator &intersection_generator;
     const CoordinateExtractor &coordinate_extractor;
 

include/extractor/guidance/motorway_handler.hpp

@@ -25,7 +25,7 @@ class MotorwayHandler : public IntersectionHandler
 {
   public:
     MotorwayHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                    const std::vector<util::Coordinate> &coordinates,
+                    const std::vector<QueryNode> &node_info_list,
                     const util::NameTable &name_table,
                     const SuffixTable &street_name_suffix_table,
                     const IntersectionGenerator &intersection_generator);

include/extractor/guidance/roundabout_handler.hpp

@@ -41,7 +41,7 @@ class RoundaboutHandler : public IntersectionHandler
 {
   public:
     RoundaboutHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                      const std::vector<util::Coordinate> &coordinates,
+                      const std::vector<QueryNode> &node_info_list,
                       const CompressedEdgeContainer &compressed_edge_container,
                       const util::NameTable &name_table,
                       const SuffixTable &street_name_suffix_table,

include/extractor/guidance/sliproad_handler.hpp

@@ -27,7 +27,7 @@ class SliproadHandler final : public IntersectionHandler
   public:
     SliproadHandler(const IntersectionGenerator &intersection_generator,
                     const util::NodeBasedDynamicGraph &node_based_graph,
-                    const std::vector<util::Coordinate> &coordinates,
+                    const std::vector<QueryNode> &node_info_list,
                     const util::NameTable &name_table,
                     const SuffixTable &street_name_suffix_table);
 

include/extractor/guidance/suppress_mode_handler.hpp

@@ -23,7 +23,7 @@ class SuppressModeHandler final : public IntersectionHandler
   public:
     SuppressModeHandler(const IntersectionGenerator &intersection_generator,
                         const util::NodeBasedDynamicGraph &node_based_graph,
-                        const std::vector<util::Coordinate> &coordinates,
+                        const std::vector<QueryNode> &node_info_list,
                         const util::NameTable &name_table,
                         const SuffixTable &street_name_suffix_table);
 

include/extractor/guidance/turn_analysis.hpp

@@ -40,7 +40,7 @@ class TurnAnalysis
 {
   public:
     TurnAnalysis(const util::NodeBasedDynamicGraph &node_based_graph,
-                 const std::vector<util::Coordinate> &coordinates,
+                 const std::vector<QueryNode> &node_info_list,
                  const RestrictionMap &restriction_map,
                  const std::unordered_set<NodeID> &barrier_nodes,
                  const CompressedEdgeContainer &compressed_edge_container,

include/extractor/guidance/turn_handler.hpp

@@ -29,7 +29,7 @@ class TurnHandler : public IntersectionHandler
 {
   public:
     TurnHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                const std::vector<util::Coordinate> &coordinates,
+                const std::vector<QueryNode> &node_info_list,
                 const util::NameTable &name_table,
                 const SuffixTable &street_name_suffix_table,
                 const IntersectionGenerator &intersection_generator);

include/extractor/io.hpp

@@ -0,0 +1,103 @@
+#ifndef OSRM_EXTRACTOR_IO_HPP
+#define OSRM_EXTRACTOR_IO_HPP
+
+#include "extractor/datasources.hpp"
+#include "extractor/nbg_to_ebg.hpp"
+#include "extractor/segment_data_container.hpp"
+
+#include "storage/io.hpp"
+
+#include <boost/assert.hpp>
+
+namespace osrm
+{
+namespace extractor
+{
+namespace io
+{
+
+inline void read(const boost::filesystem::path &path, std::vector<NBGToEBG> &mapping)
+{
+    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    reader.DeserializeVector(mapping);
+}
+
+inline void write(const boost::filesystem::path &path, const std::vector<NBGToEBG> &mapping)
+{
+    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
+    storage::io::FileWriter reader{path, fingerprint};
+
+    reader.SerializeVector(mapping);
+}
+
+inline void read(const boost::filesystem::path &path, Datasources &sources)
+{
+    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    reader.ReadInto(sources);
+}
+
+inline void write(const boost::filesystem::path &path, Datasources &sources)
+{
+    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    writer.WriteFrom(sources);
+}
+
+template <>
+inline void read(const boost::filesystem::path &path, SegmentDataContainer &segment_data)
+{
+    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    auto num_indices = reader.ReadElementCount32();
+    segment_data.index.resize(num_indices);
+    reader.ReadInto(segment_data.index.data(), num_indices);
+
+    auto num_entries = reader.ReadElementCount32();
+    segment_data.nodes.resize(num_entries);
+    segment_data.fwd_weights.resize(num_entries);
+    segment_data.rev_weights.resize(num_entries);
+    segment_data.fwd_durations.resize(num_entries);
+    segment_data.rev_durations.resize(num_entries);
+    segment_data.datasources.resize(num_entries);
+
+    reader.ReadInto(segment_data.nodes);
+    reader.ReadInto(segment_data.fwd_weights);
+    reader.ReadInto(segment_data.rev_weights);
+    reader.ReadInto(segment_data.fwd_durations);
+    reader.ReadInto(segment_data.rev_durations);
+    reader.ReadInto(segment_data.datasources);
+}
+
+template <>
+inline void write(const boost::filesystem::path &path, const SegmentDataContainer &segment_data)
+{
+    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    writer.WriteElementCount32(segment_data.index.size());
+    writer.WriteFrom(segment_data.index);
+
+    writer.WriteElementCount32(segment_data.nodes.size());
+    BOOST_ASSERT(segment_data.fwd_weights.size() == segment_data.nodes.size());
+    BOOST_ASSERT(segment_data.rev_weights.size() == segment_data.nodes.size());
+    BOOST_ASSERT(segment_data.fwd_durations.size() == segment_data.nodes.size());
+    BOOST_ASSERT(segment_data.rev_durations.size() == segment_data.nodes.size());
+    BOOST_ASSERT(segment_data.datasources.size() == segment_data.nodes.size());
+    writer.WriteFrom(segment_data.nodes);
+    writer.WriteFrom(segment_data.fwd_weights);
+    writer.WriteFrom(segment_data.rev_weights);
+    writer.WriteFrom(segment_data.fwd_durations);
+    writer.WriteFrom(segment_data.rev_durations);
+    writer.WriteFrom(segment_data.datasources);
+}
+}
+}
+}
+
+#endif

include/extractor/profile_properties.hpp

@@ -87,7 +87,6 @@ struct ProfileProperties
     //! stores the name of the weight (e.g. 'duration', 'distance', 'safety')
     char weight_name[MAX_WEIGHT_NAME_LENGTH + 1];
     unsigned weight_precision = 1;
-    bool force_split_edges = false;
 };
 }
 }

include/extractor/segment_data_container.hpp

@@ -1,11 +1,8 @@
 #ifndef OSRM_EXTRACTOR_SEGMENT_DATA_CONTAINER_HPP_
 #define OSRM_EXTRACTOR_SEGMENT_DATA_CONTAINER_HPP_
 
+#include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"
-#include "util/vector_view.hpp"
-
-#include "storage/io_fwd.hpp"
-#include "storage/shared_memory_ownership.hpp"
 
 #include <boost/filesystem/path.hpp>
 #include <boost/range/adaptor/reversed.hpp>
@@ -25,24 +22,24 @@ class CompressedEdgeContainer;
 
 namespace detail
 {
-template <storage::Ownership Ownership> class SegmentDataContainerImpl;
+template <bool UseShareMemory> class SegmentDataContainerImpl;
 }
 
-namespace serialization
+namespace io
 {
-template <storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader,
-                 detail::SegmentDataContainerImpl<Ownership> &segment_data);
-template <storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer,
-                  const detail::SegmentDataContainerImpl<Ownership> &segment_data);
+template <bool UseShareMemory>
+inline void read(const boost::filesystem::path &path,
+                 detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
+template <bool UseShareMemory>
+inline void write(const boost::filesystem::path &path,
+                  const detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
 }
 
 namespace detail
 {
-template <storage::Ownership Ownership> class SegmentDataContainerImpl
+template <bool UseShareMemory> class SegmentDataContainerImpl
 {
-    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
+    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::vector;
 
     friend CompressedEdgeContainer;
 
@@ -192,11 +189,11 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
     auto GetNumberOfSegments() const { return fwd_weights.size(); }
 
     friend void
-    serialization::read<Ownership>(storage::io::FileReader &reader,
-                                   detail::SegmentDataContainerImpl<Ownership> &segment_data);
-    friend void serialization::write<Ownership>(
-        storage::io::FileWriter &writer,
-        const detail::SegmentDataContainerImpl<Ownership> &segment_data);
+    io::read<UseShareMemory>(const boost::filesystem::path &path,
+                             detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
+    friend void
+    io::write<UseShareMemory>(const boost::filesystem::path &path,
+                              const detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
 
   private:
     Vector<std::uint32_t> index;
@@ -209,8 +206,8 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
 };
 }
 
-using SegmentDataView = detail::SegmentDataContainerImpl<storage::Ownership::View>;
-using SegmentDataContainer = detail::SegmentDataContainerImpl<storage::Ownership::Container>;
+using SegmentDataView = detail::SegmentDataContainerImpl<true>;
+using SegmentDataContainer = detail::SegmentDataContainerImpl<false>;
 }
 }
 

include/extractor/serialization.hpp

@@ -1,88 +0,0 @@
-#ifndef OSRM_EXTRACTOR_IO_HPP
-#define OSRM_EXTRACTOR_IO_HPP
-
-#include "extractor/datasources.hpp"
-#include "extractor/nbg_to_ebg.hpp"
-#include "extractor/segment_data_container.hpp"
-#include "extractor/turn_data_container.hpp"
-
-#include "storage/io.hpp"
-#include "storage/serialization.hpp"
-
-#include <boost/assert.hpp>
-
-namespace osrm
-{
-namespace extractor
-{
-namespace serialization
-{
-
-inline void read(storage::io::FileReader &reader, Datasources &sources)
-{
-    reader.ReadInto(sources);
-}
-
-inline void write(storage::io::FileWriter &writer, Datasources &sources)
-{
-    writer.WriteFrom(sources);
-}
-
-template <storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader,
-                 detail::SegmentDataContainerImpl<Ownership> &segment_data)
-{
-    storage::serialization::read(reader, segment_data.index);
-    storage::serialization::read(reader, segment_data.nodes);
-    storage::serialization::read(reader, segment_data.fwd_weights);
-    storage::serialization::read(reader, segment_data.rev_weights);
-    storage::serialization::read(reader, segment_data.fwd_durations);
-    storage::serialization::read(reader, segment_data.rev_durations);
-    storage::serialization::read(reader, segment_data.datasources);
-}
-
-template <storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer,
-                  const detail::SegmentDataContainerImpl<Ownership> &segment_data)
-{
-    storage::serialization::write(writer, segment_data.index);
-    storage::serialization::write(writer, segment_data.nodes);
-    storage::serialization::write(writer, segment_data.fwd_weights);
-    storage::serialization::write(writer, segment_data.rev_weights);
-    storage::serialization::write(writer, segment_data.fwd_durations);
-    storage::serialization::write(writer, segment_data.rev_durations);
-    storage::serialization::write(writer, segment_data.datasources);
-}
-
-template <storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader,
-                 detail::TurnDataContainerImpl<Ownership> &turn_data_container)
-{
-    storage::serialization::read(reader, turn_data_container.geometry_ids);
-    storage::serialization::read(reader, turn_data_container.name_ids);
-    storage::serialization::read(reader, turn_data_container.turn_instructions);
-    storage::serialization::read(reader, turn_data_container.lane_data_ids);
-    storage::serialization::read(reader, turn_data_container.travel_modes);
-    storage::serialization::read(reader, turn_data_container.entry_class_ids);
-    storage::serialization::read(reader, turn_data_container.pre_turn_bearings);
-    storage::serialization::read(reader, turn_data_container.post_turn_bearings);
-}
-
-template <storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer,
-                  const detail::TurnDataContainerImpl<Ownership> &turn_data_container)
-{
-    storage::serialization::write(writer, turn_data_container.geometry_ids);
-    storage::serialization::write(writer, turn_data_container.name_ids);
-    storage::serialization::write(writer, turn_data_container.turn_instructions);
-    storage::serialization::write(writer, turn_data_container.lane_data_ids);
-    storage::serialization::write(writer, turn_data_container.travel_modes);
-    storage::serialization::write(writer, turn_data_container.entry_class_ids);
-    storage::serialization::write(writer, turn_data_container.pre_turn_bearings);
-    storage::serialization::write(writer, turn_data_container.post_turn_bearings);
-}
-}
-}
-}
-
-#endif

include/extractor/turn_data_container.hpp

@@ -1,130 +0,0 @@
-#ifndef OSRM_EXTRACTOR_TURN_DATA_CONTAINER_HPP
-#define OSRM_EXTRACTOR_TURN_DATA_CONTAINER_HPP
-
-#include "extractor/guidance/turn_instruction.hpp"
-#include "extractor/travel_mode.hpp"
-
-#include "storage/io_fwd.hpp"
-#include "storage/shared_memory_ownership.hpp"
-
-#include "util/guidance/turn_bearing.hpp"
-#include "util/vector_view.hpp"
-
-#include "util/typedefs.hpp"
-
-namespace osrm
-{
-namespace extractor
-{
-namespace detail
-{
-template <storage::Ownership Ownership> class TurnDataContainerImpl;
-}
-
-namespace serialization
-{
-template <storage::Ownership Ownership>
-void read(storage::io::FileReader &reader, detail::TurnDataContainerImpl<Ownership> &turn_data);
-
-template <storage::Ownership Ownership>
-void write(storage::io::FileWriter &writer,
-           const detail::TurnDataContainerImpl<Ownership> &turn_data);
-}
-
-namespace detail
-{
-template <storage::Ownership Ownership> class TurnDataContainerImpl
-{
-    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
-
-  public:
-    TurnDataContainerImpl() = default;
-
-    TurnDataContainerImpl(Vector<GeometryID> geometry_ids_,
-                          Vector<NameID> name_ids_,
-                          Vector<extractor::guidance::TurnInstruction> turn_instructions_,
-                          Vector<LaneDataID> lane_data_ids_,
-                          Vector<extractor::TravelMode> travel_modes_,
-                          Vector<EntryClassID> entry_class_ids_,
-                          Vector<util::guidance::TurnBearing> pre_turn_bearings_,
-                          Vector<util::guidance::TurnBearing> post_turn_bearings_)
-        : geometry_ids(std::move(geometry_ids_)), name_ids(std::move(name_ids_)),
-          turn_instructions(std::move(turn_instructions_)),
-          lane_data_ids(std::move(lane_data_ids_)), travel_modes(std::move(travel_modes_)),
-          entry_class_ids(std::move(entry_class_ids_)),
-          pre_turn_bearings(std::move(pre_turn_bearings_)),
-          post_turn_bearings(std::move(post_turn_bearings_))
-    {
-    }
-
-    GeometryID GetGeometryID(const EdgeID id) const { return geometry_ids[id]; }
-
-    EntryClassID GetEntryClassID(const EdgeID id) const { return entry_class_ids[id]; }
-
-    extractor::TravelMode GetTravelMode(const EdgeID id) const { return travel_modes[id]; }
-
-    util::guidance::TurnBearing GetPreTurnBearing(const EdgeID id) const
-    {
-        return pre_turn_bearings[id];
-    }
-
-    util::guidance::TurnBearing GetPostTurnBearing(const EdgeID id) const
-    {
-        return post_turn_bearings[id];
-    }
-
-    LaneDataID GetLaneDataID(const EdgeID id) const { return lane_data_ids[id]; }
-
-    bool HasLaneData(const EdgeID id) const { return INVALID_LANE_DATAID != lane_data_ids[id]; }
-
-    NameID GetNameID(const EdgeID id) const { return name_ids[id]; }
-
-    extractor::guidance::TurnInstruction GetTurnInstruction(const EdgeID id) const
-    {
-        return turn_instructions[id];
-    }
-
-    // Used by EdgeBasedGraphFactory to fill data structure
-    template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
-    void push_back(GeometryID geometry_id,
-                   NameID name_id,
-                   extractor::guidance::TurnInstruction turn_instruction,
-                   LaneDataID lane_data_id,
-                   EntryClassID entry_class_id,
-                   extractor::TravelMode travel_mode,
-                   util::guidance::TurnBearing pre_turn_bearing,
-                   util::guidance::TurnBearing post_turn_bearing)
-    {
-        geometry_ids.push_back(geometry_id);
-        name_ids.push_back(name_id);
-        turn_instructions.push_back(turn_instruction);
-        lane_data_ids.push_back(lane_data_id);
-        travel_modes.push_back(travel_mode);
-        entry_class_ids.push_back(entry_class_id);
-        pre_turn_bearings.push_back(pre_turn_bearing);
-        post_turn_bearings.push_back(post_turn_bearing);
-    }
-
-    friend void serialization::read<Ownership>(storage::io::FileReader &reader,
-                                               TurnDataContainerImpl &turn_data_container);
-    friend void serialization::write<Ownership>(storage::io::FileWriter &writer,
-                                                const TurnDataContainerImpl &turn_data_container);
-
-  private:
-    Vector<GeometryID> geometry_ids;
-    Vector<NameID> name_ids;
-    Vector<extractor::guidance::TurnInstruction> turn_instructions;
-    Vector<LaneDataID> lane_data_ids;
-    Vector<extractor::TravelMode> travel_modes;
-    Vector<EntryClassID> entry_class_ids;
-    Vector<util::guidance::TurnBearing> pre_turn_bearings;
-    Vector<util::guidance::TurnBearing> post_turn_bearings;
-};
-}
-
-using TurnDataContainer = detail::TurnDataContainerImpl<storage::Ownership::Container>;
-using TurnDataView = detail::TurnDataContainerImpl<storage::Ownership::View>;
-}
-}
-
-#endif

include/nodejs/node_osrm_support.hpp

@@ -112,13 +112,7 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
     auto params = Nan::To<v8::Object>(args[0]).ToLocalChecked();
 
     auto path = params->Get(Nan::New("path").ToLocalChecked());
-    if (path.IsEmpty())
-        return engine_config_ptr();
-
     auto shared_memory = params->Get(Nan::New("shared_memory").ToLocalChecked());
-    if (shared_memory.IsEmpty())
-        return engine_config_ptr();
-
     if (!path->IsUndefined())
     {
         engine_config->storage_config =
@@ -146,9 +140,6 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
     }
 
     auto algorithm = params->Get(Nan::New("algorithm").ToLocalChecked());
-    if (algorithm.IsEmpty())
-        return engine_config_ptr();
-
     if (algorithm->IsString())
     {
         auto algorithm_str = Nan::To<v8::String>(algorithm).ToLocalChecked();
@@ -189,8 +180,6 @@ parseCoordinateArray(const v8::Local<v8::Array> &coordinates_array)
     for (uint32_t i = 0; i < coordinates_array->Length(); ++i)
     {
         v8::Local<v8::Value> coordinate = coordinates_array->Get(i);
-        if (coordinate.IsEmpty())
-            return resulting_coordinates;
 
         if (!coordinate->IsArray())
         {
@@ -258,9 +247,6 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
     v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[0]).ToLocalChecked();
 
     v8::Local<v8::Value> coordinates = obj->Get(Nan::New("coordinates").ToLocalChecked());
-    if (coordinates.IsEmpty())
-        return false;
-
     if (coordinates->IsUndefined())
     {
         Nan::ThrowError("Must provide a coordinates property");
@@ -301,8 +287,6 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
     if (obj->Has(Nan::New("bearings").ToLocalChecked()))
     {
         v8::Local<v8::Value> bearings = obj->Get(Nan::New("bearings").ToLocalChecked());
-        if (bearings.IsEmpty())
-            return false;
 
         if (!bearings->IsArray())
         {
@@ -321,8 +305,6 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
         for (uint32_t i = 0; i < bearings_array->Length(); ++i)
         {
             v8::Local<v8::Value> bearing_raw = bearings_array->Get(i);
-            if (bearing_raw.IsEmpty())
-                return false;
 
             if (bearing_raw->IsNull())
             {
@@ -367,8 +349,6 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
     if (obj->Has(Nan::New("hints").ToLocalChecked()))
     {
         v8::Local<v8::Value> hints = obj->Get(Nan::New("hints").ToLocalChecked());
-        if (hints.IsEmpty())
-            return false;
 
         if (!hints->IsArray())
         {
@@ -387,9 +367,6 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
         for (uint32_t i = 0; i < hints_array->Length(); ++i)
         {
             v8::Local<v8::Value> hint = hints_array->Get(i);
-            if (hint.IsEmpty())
-                return false;
-
             if (hint->IsString())
             {
                 if (hint->ToString()->Length() == 0)
@@ -416,8 +393,6 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
     if (obj->Has(Nan::New("radiuses").ToLocalChecked()))
     {
         v8::Local<v8::Value> radiuses = obj->Get(Nan::New("radiuses").ToLocalChecked());
-        if (radiuses.IsEmpty())
-            return false;
 
         if (!radiuses->IsArray())
         {
@@ -436,9 +411,6 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
         for (uint32_t i = 0; i < radiuses_array->Length(); ++i)
         {
             v8::Local<v8::Value> radius = radiuses_array->Get(i);
-            if (radius.IsEmpty())
-                return false;
-
             if (radius->IsNull())
             {
                 params->radiuses.emplace_back();
@@ -458,8 +430,6 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
     if (obj->Has(Nan::New("generate_hints").ToLocalChecked()))
     {
         v8::Local<v8::Value> generate_hints = obj->Get(Nan::New("generate_hints").ToLocalChecked());
-        if (generate_hints.IsEmpty())
-            return false;
 
         if (!generate_hints->IsBoolean())
         {
@@ -479,9 +449,6 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
     if (obj->Has(Nan::New("steps").ToLocalChecked()))
     {
         auto steps = obj->Get(Nan::New("steps").ToLocalChecked());
-        if (steps.IsEmpty())
-            return false;
-
         if (steps->IsBoolean())
         {
             params->steps = steps->BooleanValue();
@@ -496,9 +463,6 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
     if (obj->Has(Nan::New("annotations").ToLocalChecked()))
     {
         auto annotations = obj->Get(Nan::New("annotations").ToLocalChecked());
-        if (annotations.IsEmpty())
-            return false;
-
         if (annotations->IsBoolean())
         {
             params->annotations = annotations->BooleanValue();
@@ -559,8 +523,6 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
     if (obj->Has(Nan::New("geometries").ToLocalChecked()))
     {
         v8::Local<v8::Value> geometries = obj->Get(Nan::New("geometries").ToLocalChecked());
-        if (geometries.IsEmpty())
-            return false;
 
         if (!geometries->IsString())
         {
@@ -593,8 +555,6 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
     if (obj->Has(Nan::New("overview").ToLocalChecked()))
     {
         v8::Local<v8::Value> overview = obj->Get(Nan::New("overview").ToLocalChecked());
-        if (overview.IsEmpty())
-            return false;
 
         if (!overview->IsString())
         {
@@ -641,13 +601,9 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
     if (obj->Has(Nan::New("continue_straight").ToLocalChecked()))
     {
         auto value = obj->Get(Nan::New("continue_straight").ToLocalChecked());
-        if (value.IsEmpty())
-            return route_parameters_ptr();
-
         if (!value->IsBoolean() && !value->IsNull())
         {
             Nan::ThrowError("'continue_straight' parama must be boolean or null");
-            return route_parameters_ptr();
         }
         if (value->IsBoolean())
         {
@@ -658,13 +614,9 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
     if (obj->Has(Nan::New("alternatives").ToLocalChecked()))
     {
         auto value = obj->Get(Nan::New("alternatives").ToLocalChecked());
-        if (value.IsEmpty())
-            return route_parameters_ptr();
-
         if (!value->IsBoolean())
         {
             Nan::ThrowError("'alternatives' parama must be boolean");
-            return route_parameters_ptr();
         }
         params->alternatives = value->BooleanValue();
     }
@@ -706,8 +658,6 @@ argumentsToTileParameters(const Nan::FunctionCallbackInfo<v8::Value> &args, bool
     v8::Local<v8::Value> x = array->Get(0);
     v8::Local<v8::Value> y = array->Get(1);
     v8::Local<v8::Value> z = array->Get(2);
-    if (x.IsEmpty() || y.IsEmpty() || z.IsEmpty())
-        return tile_parameters_ptr();
 
     if (!x->IsUint32() && !x->IsUndefined())
     {
@@ -748,8 +698,6 @@ argumentsToNearestParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         return nearest_parameters_ptr();
 
     v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[0]).ToLocalChecked();
-    if (obj.IsEmpty())
-        return nearest_parameters_ptr();
 
     if (obj->Has(Nan::New("number").ToLocalChecked()))
     {
@@ -787,14 +735,10 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         return table_parameters_ptr();
 
     v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[0]).ToLocalChecked();
-    if (obj.IsEmpty())
-        return table_parameters_ptr();
 
     if (obj->Has(Nan::New("sources").ToLocalChecked()))
     {
         v8::Local<v8::Value> sources = obj->Get(Nan::New("sources").ToLocalChecked());
-        if (sources.IsEmpty())
-            return table_parameters_ptr();
 
         if (!sources->IsArray())
         {
@@ -806,9 +750,6 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         for (uint32_t i = 0; i < sources_array->Length(); ++i)
         {
             v8::Local<v8::Value> source = sources_array->Get(i);
-            if (source.IsEmpty())
-                return table_parameters_ptr();
-
             if (source->IsUint32())
             {
                 size_t source_value = static_cast<size_t>(source->NumberValue());
@@ -832,8 +773,6 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
     if (obj->Has(Nan::New("destinations").ToLocalChecked()))
     {
         v8::Local<v8::Value> destinations = obj->Get(Nan::New("destinations").ToLocalChecked());
-        if (destinations.IsEmpty())
-            return table_parameters_ptr();
 
         if (!destinations->IsArray())
         {
@@ -845,9 +784,6 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         for (uint32_t i = 0; i < destinations_array->Length(); ++i)
         {
             v8::Local<v8::Value> destination = destinations_array->Get(i);
-            if (destination.IsEmpty())
-                return table_parameters_ptr();
-
             if (destination->IsUint32())
             {
                 size_t destination_value = static_cast<size_t>(destination->NumberValue());
@@ -891,9 +827,6 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
     if (obj->Has(Nan::New("roundtrip").ToLocalChecked()))
     {
         auto roundtrip = obj->Get(Nan::New("roundtrip").ToLocalChecked());
-        if (roundtrip.IsEmpty())
-            return trip_parameters_ptr();
-
         if (roundtrip->IsBoolean())
         {
             params->roundtrip = roundtrip->BooleanValue();
@@ -908,8 +841,6 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
     if (obj->Has(Nan::New("source").ToLocalChecked()))
     {
         v8::Local<v8::Value> source = obj->Get(Nan::New("source").ToLocalChecked());
-        if (source.IsEmpty())
-            return trip_parameters_ptr();
 
         if (!source->IsString())
         {
@@ -937,8 +868,6 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
     if (obj->Has(Nan::New("destination").ToLocalChecked()))
     {
         v8::Local<v8::Value> destination = obj->Get(Nan::New("destination").ToLocalChecked());
-        if (destination.IsEmpty())
-            return trip_parameters_ptr();
 
         if (!destination->IsString())
         {
@@ -980,8 +909,6 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
     if (obj->Has(Nan::New("timestamps").ToLocalChecked()))
     {
         v8::Local<v8::Value> timestamps = obj->Get(Nan::New("timestamps").ToLocalChecked());
-        if (timestamps.IsEmpty())
-            return match_parameters_ptr();
 
         if (!timestamps->IsArray())
         {
@@ -1001,9 +928,6 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         for (uint32_t i = 0; i < timestamps_array->Length(); ++i)
         {
             v8::Local<v8::Value> timestamp = timestamps_array->Get(i);
-            if (timestamp.IsEmpty())
-                return match_parameters_ptr();
-
             if (!timestamp->IsNumber())
             {
                 Nan::ThrowError("Timestamps array items must be numbers");

include/partition/cell_storage.hpp

@@ -6,11 +6,10 @@
 #include "util/assert.hpp"
 #include "util/for_each_range.hpp"
 #include "util/log.hpp"
+#include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"
-#include "util/vector_view.hpp"
 
-#include "storage/io_fwd.hpp"
-#include "storage/shared_memory_ownership.hpp"
+#include "storage/io.hpp"
 
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/range/iterator_range.hpp>
@@ -27,23 +26,24 @@ namespace partition
 {
 namespace detail
 {
-template <storage::Ownership Ownership> class CellStorageImpl;
+template <bool UseShareMemory> class CellStorageImpl;
 }
-using CellStorage = detail::CellStorageImpl<storage::Ownership::Container>;
-using CellStorageView = detail::CellStorageImpl<storage::Ownership::View>;
+using CellStorage = detail::CellStorageImpl<false>;
+using CellStorageView = detail::CellStorageImpl<true>;
 
-namespace serialization
+namespace io
 {
-template <storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader, detail::CellStorageImpl<Ownership> &storage);
-template <storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer,
-                  const detail::CellStorageImpl<Ownership> &storage);
+template <bool UseShareMemory>
+inline void read(const boost::filesystem::path &path,
+                 detail::CellStorageImpl<UseShareMemory> &storage);
+template <bool UseShareMemory>
+inline void write(const boost::filesystem::path &path,
+                  const detail::CellStorageImpl<UseShareMemory> &storage);
 }
 
 namespace detail
 {
-template <storage::Ownership Ownership> class CellStorageImpl
+template <bool UseShareMemory> class CellStorageImpl
 {
   public:
     using WeightOffset = std::uint32_t;
@@ -65,7 +65,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
     };
 
   private:
-    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
+    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::vector;
 
     // Implementation of the cell view. We need a template parameter here
     // because we need to derive a read-only and read-write view from this.
@@ -185,8 +185,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
     CellStorageImpl() {}
 
-    template <typename GraphT,
-              typename = std::enable_if<Ownership == storage::Ownership::Container>>
+    template <typename GraphT, typename = std::enable_if<!UseShareMemory>>
     CellStorageImpl(const partition::MultiLevelPartition &partition, const GraphT &base_graph)
     {
         // pre-allocate storge for CellData so we can have random access to it by cell id
@@ -315,7 +314,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
         weights.resize(weight_offset + 1, INVALID_EDGE_WEIGHT);
     }
 
-    template <typename = std::enable_if<Ownership == storage::Ownership::View>>
+    template <typename = std::enable_if<UseShareMemory>>
     CellStorageImpl(Vector<EdgeWeight> weights_,
                     Vector<NodeID> source_boundary_,
                     Vector<NodeID> destination_boundary_,
@@ -340,8 +339,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
                          destination_boundary.empty() ? nullptr : destination_boundary.data()};
     }
 
-    template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
-    Cell GetCell(LevelID level, CellID id)
+    template <typename = std::enable_if<!UseShareMemory>> Cell GetCell(LevelID level, CellID id)
     {
         const auto level_index = LevelIDToIndex(level);
         BOOST_ASSERT(level_index < level_to_cell_offset.size());
@@ -352,10 +350,10 @@ template <storage::Ownership Ownership> class CellStorageImpl
             cells[cell_index], weights.data(), source_boundary.data(), destination_boundary.data()};
     }
 
-    friend void serialization::read<Ownership>(storage::io::FileReader &reader,
-                                               detail::CellStorageImpl<Ownership> &storage);
-    friend void serialization::write<Ownership>(storage::io::FileWriter &writer,
-                                                const detail::CellStorageImpl<Ownership> &storage);
+    friend void io::read<UseShareMemory>(const boost::filesystem::path &path,
+                                         detail::CellStorageImpl<UseShareMemory> &storage);
+    friend void io::write<UseShareMemory>(const boost::filesystem::path &path,
+                                          const detail::CellStorageImpl<UseShareMemory> &storage);
 
   private:
     Vector<EdgeWeight> weights;

include/partition/files.hpp

@@ -1,104 +0,0 @@
-#ifndef OSRM_PARTITION_SERILIZATION_HPP
-#define OSRM_PARTITION_SERILIZATION_HPP
-
-#include "customizer/edge_based_graph.hpp"
-
-#include "partition/serialization.hpp"
-
-#include "storage/io.hpp"
-
-namespace osrm
-{
-namespace partition
-{
-namespace files
-{
-
-// reads .osrm.mldgr file
-template <typename MultiLevelGraphT>
-inline void readGraph(const boost::filesystem::path &path, MultiLevelGraphT &graph)
-{
-    static_assert(std::is_same<customizer::MultiLevelEdgeBasedGraphView, MultiLevelGraphT>::value ||
-                      std::is_same<customizer::MultiLevelEdgeBasedGraph, MultiLevelGraphT>::value,
-                  "");
-
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    serialization::read(reader, graph);
-}
-
-// writes .osrm.mldgr file
-template <typename MultiLevelGraphT>
-inline void writeGraph(const boost::filesystem::path &path, const MultiLevelGraphT &graph)
-{
-    static_assert(std::is_same<customizer::MultiLevelEdgeBasedGraphView, MultiLevelGraphT>::value ||
-                      std::is_same<customizer::MultiLevelEdgeBasedGraph, MultiLevelGraphT>::value,
-                  "");
-
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    serialization::write(writer, graph);
-}
-
-// read .osrm.partition file
-template <typename MultiLevelPartitionT>
-inline void readPartition(const boost::filesystem::path &path, MultiLevelPartitionT &mlp)
-{
-    static_assert(std::is_same<MultiLevelPartitionView, MultiLevelPartitionT>::value ||
-                      std::is_same<MultiLevelPartition, MultiLevelPartitionT>::value,
-                  "");
-
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    serialization::read(reader, mlp);
-}
-
-// writes .osrm.partition file
-template <typename MultiLevelPartitionT>
-inline void writePartition(const boost::filesystem::path &path, const MultiLevelPartitionT &mlp)
-{
-    static_assert(std::is_same<MultiLevelPartitionView, MultiLevelPartitionT>::value ||
-                      std::is_same<MultiLevelPartition, MultiLevelPartitionT>::value,
-                  "");
-
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    serialization::write(writer, mlp);
-}
-
-// reads .osrm.cells file
-template <typename CellStorageT>
-inline void readCells(const boost::filesystem::path &path, CellStorageT &storage)
-{
-    static_assert(std::is_same<CellStorageView, CellStorageT>::value ||
-                      std::is_same<CellStorage, CellStorageT>::value,
-                  "");
-
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    serialization::read(reader, storage);
-}
-
-// writes .osrm.cells file
-template <typename CellStorageT>
-inline void writeCells(const boost::filesystem::path &path, CellStorageT &storage)
-{
-    static_assert(std::is_same<CellStorageView, CellStorageT>::value ||
-                      std::is_same<CellStorage, CellStorageT>::value,
-                  "");
-
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    serialization::write(writer, storage);
-}
-}
-}
-}
-
-#endif

include/partition/io.hpp

@@ -0,0 +1,89 @@
+#ifndef OSRM_PARTITION_IO_HPP
+#define OSRM_PARTITION_IO_HPP
+
+#include "partition/cell_storage.hpp"
+#include "partition/edge_based_graph.hpp"
+#include "partition/multi_level_graph.hpp"
+#include "partition/multi_level_partition.hpp"
+
+#include "storage/io.hpp"
+
+namespace osrm
+{
+namespace partition
+{
+namespace io
+{
+
+template <typename EdgeDataT, bool UseSharedMemory>
+inline void read(const boost::filesystem::path &path,
+                 MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph)
+{
+    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    reader.DeserializeVector(graph.node_array);
+    reader.DeserializeVector(graph.edge_array);
+    reader.DeserializeVector(graph.edge_to_level);
+}
+
+template <typename EdgeDataT, bool UseSharedMemory>
+inline void write(const boost::filesystem::path &path,
+                  const MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph)
+{
+    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    writer.SerializeVector(graph.node_array);
+    writer.SerializeVector(graph.edge_array);
+    writer.SerializeVector(graph.node_to_edge_offset);
+}
+
+template <> inline void read(const boost::filesystem::path &path, MultiLevelPartition &mlp)
+{
+    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    reader.ReadInto<MultiLevelPartition::LevelData>(mlp.level_data);
+    reader.DeserializeVector(mlp.partition);
+    reader.DeserializeVector(mlp.cell_to_children);
+}
+
+template <> inline void write(const boost::filesystem::path &path, const MultiLevelPartition &mlp)
+{
+    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    writer.WriteOne(mlp.level_data);
+    writer.SerializeVector(mlp.partition);
+    writer.SerializeVector(mlp.cell_to_children);
+}
+
+template <> inline void read(const boost::filesystem::path &path, CellStorage &storage)
+{
+    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    reader.DeserializeVector(storage.weights);
+    reader.DeserializeVector(storage.source_boundary);
+    reader.DeserializeVector(storage.destination_boundary);
+    reader.DeserializeVector(storage.cells);
+    reader.DeserializeVector(storage.level_to_cell_offset);
+}
+
+template <> inline void write(const boost::filesystem::path &path, const CellStorage &storage)
+{
+    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    writer.SerializeVector(storage.weights);
+    writer.SerializeVector(storage.source_boundary);
+    writer.SerializeVector(storage.destination_boundary);
+    writer.SerializeVector(storage.cells);
+    writer.SerializeVector(storage.level_to_cell_offset);
+}
+}
+}
+}
+
+#endif

include/partition/multi_level_graph.hpp

@@ -3,11 +3,7 @@
 
 #include "partition/multi_level_partition.hpp"
 
-#include "storage/io_fwd.hpp"
-#include "storage/shared_memory_ownership.hpp"
-
 #include "util/static_graph.hpp"
-#include "util/vector_view.hpp"
 
 #include <tbb/parallel_sort.h>
 
@@ -16,26 +12,26 @@
 
 namespace osrm
 {
-
 namespace partition
 {
-template <typename EdgeDataT, storage::Ownership Ownership> class MultiLevelGraph;
+template <typename EdgeDataT, bool UseSharedMemory> class MultiLevelGraph;
 
-namespace serialization
+namespace io
 {
-template <typename EdgeDataT, storage::Ownership Ownership>
-void read(storage::io::FileReader &reader, MultiLevelGraph<EdgeDataT, Ownership> &graph);
+template <typename EdgeDataT, bool UseSharedMemory>
+void read(const boost::filesystem::path &path, MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
 
-template <typename EdgeDataT, storage::Ownership Ownership>
-void write(storage::io::FileWriter &writer, const MultiLevelGraph<EdgeDataT, Ownership> &graph);
+template <typename EdgeDataT, bool UseSharedMemory>
+void write(const boost::filesystem::path &path,
+           const MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
 }
 
-template <typename EdgeDataT, storage::Ownership Ownership>
-class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
+template <typename EdgeDataT, bool UseSharedMemory>
+class MultiLevelGraph : public util::StaticGraph<EdgeDataT, UseSharedMemory>
 {
   private:
-    using SuperT = util::StaticGraph<EdgeDataT, Ownership>;
-    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
+    using SuperT = util::StaticGraph<EdgeDataT, UseSharedMemory>;
+    template <typename T> using Vector = typename util::ShM<T, UseSharedMemory>::vector;
 
   public:
     // We limit each node to have 255 edges
@@ -194,11 +190,11 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
     }
 
     friend void
-    serialization::read<EdgeDataT, Ownership>(storage::io::FileReader &reader,
-                                              MultiLevelGraph<EdgeDataT, Ownership> &graph);
+    io::read<EdgeDataT, UseSharedMemory>(const boost::filesystem::path &path,
+                                         MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
     friend void
-    serialization::write<EdgeDataT, Ownership>(storage::io::FileWriter &writer,
-                                               const MultiLevelGraph<EdgeDataT, Ownership> &graph);
+    io::write<EdgeDataT, UseSharedMemory>(const boost::filesystem::path &path,
+                                          const MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
 
     Vector<EdgeOffset> node_to_edge_offset;
 };

include/partition/multi_level_partition.hpp

@@ -4,11 +4,10 @@
 #include "util/exception.hpp"
 #include "util/for_each_pair.hpp"
 #include "util/msb.hpp"
+#include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"
-#include "util/vector_view.hpp"
 
-#include "storage/io_fwd.hpp"
-#include "storage/shared_memory_ownership.hpp"
+#include "storage/io.hpp"
 
 #include <algorithm>
 #include <array>
@@ -26,29 +25,31 @@ namespace partition
 {
 namespace detail
 {
-template <storage::Ownership Ownership> class MultiLevelPartitionImpl;
+template <bool UseShareMemory> class MultiLevelPartitionImpl;
 }
-using MultiLevelPartition = detail::MultiLevelPartitionImpl<storage::Ownership::Container>;
-using MultiLevelPartitionView = detail::MultiLevelPartitionImpl<storage::Ownership::View>;
+using MultiLevelPartition = detail::MultiLevelPartitionImpl<false>;
+using MultiLevelPartitionView = detail::MultiLevelPartitionImpl<true>;
 
-namespace serialization
+namespace io
 {
-template <storage::Ownership Ownership>
-void read(storage::io::FileReader &reader, detail::MultiLevelPartitionImpl<Ownership> &mlp);
-template <storage::Ownership Ownership>
-void write(storage::io::FileWriter &writer, const detail::MultiLevelPartitionImpl<Ownership> &mlp);
+template <bool UseShareMemory>
+void read(const boost::filesystem::path &file,
+          detail::MultiLevelPartitionImpl<UseShareMemory> &mlp);
+template <bool UseShareMemory>
+void write(const boost::filesystem::path &file,
+           const detail::MultiLevelPartitionImpl<UseShareMemory> &mlp);
 }
 
 namespace detail
 {
 
-template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
+template <bool UseShareMemory> class MultiLevelPartitionImpl final
 {
     // we will support at most 16 levels
     static const constexpr std::uint8_t MAX_NUM_LEVEL = 16;
     static const constexpr std::uint8_t NUM_PARTITION_BITS = sizeof(PartitionID) * CHAR_BIT;
 
-    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
+    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::vector;
 
   public:
     // Contains all data necessary to describe the level hierarchy
@@ -61,16 +62,13 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
         std::array<LevelID, NUM_PARTITION_BITS> bit_to_level;
         std::array<std::uint32_t, MAX_NUM_LEVEL - 1> lidx_to_children_offsets;
     };
-    using LevelDataPtr = typename std::conditional<Ownership == storage::Ownership::View,
-                                                   LevelData *,
-                                                   std::unique_ptr<LevelData>>::type;
 
-    MultiLevelPartitionImpl();
+    MultiLevelPartitionImpl() = default;
 
     // cell_sizes is index by level (starting at 0, the base graph).
     // However level 0 always needs to have cell size 1, since it is the
     // basegraph.
-    template <typename = typename std::enable_if<Ownership == storage::Ownership::Container>>
+    template <typename = typename std::enable_if<!UseShareMemory>>
     MultiLevelPartitionImpl(const std::vector<std::vector<CellID>> &partitions,
                             const std::vector<std::uint32_t> &lidx_to_num_cells)
         : level_data(MakeLevelData(lidx_to_num_cells))
@@ -78,8 +76,8 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
         InitializePartitionIDs(partitions);
     }
 
-    template <typename = typename std::enable_if<Ownership == storage::Ownership::View>>
-    MultiLevelPartitionImpl(LevelDataPtr level_data,
+    template <typename = typename std::enable_if<UseShareMemory>>
+    MultiLevelPartitionImpl(LevelData level_data,
                             Vector<PartitionID> partition_,
                             Vector<CellID> cell_to_children_)
         : level_data(std::move(level_data)), partition(std::move(partition_)),
@@ -92,8 +90,8 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
     {
         auto p = partition[node];
         auto lidx = LevelIDToIndex(l);
-        auto masked = p & level_data->lidx_to_mask[lidx];
-        return masked >> level_data->lidx_to_offset[lidx];
+        auto masked = p & level_data.lidx_to_mask[lidx];
+        return masked >> level_data.lidx_to_offset[lidx];
     }
 
     LevelID GetQueryLevel(NodeID start, NodeID target, NodeID node) const
@@ -108,10 +106,10 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
             return 0;
 
         auto msb = util::msb(partition[first] ^ partition[second]);
-        return level_data->bit_to_level[msb];
+        return level_data.bit_to_level[msb];
     }
 
-    std::uint8_t GetNumberOfLevels() const { return level_data->num_level; }
+    std::uint8_t GetNumberOfLevels() const { return level_data.num_level; }
 
     std::uint32_t GetNumberOfCells(LevelID level) const
     {
@@ -123,7 +121,7 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
     {
         BOOST_ASSERT(level > 1);
         auto lidx = LevelIDToIndex(level);
-        auto offset = level_data->lidx_to_children_offsets[lidx];
+        auto offset = level_data.lidx_to_children_offsets[lidx];
         return cell_to_children[offset + cell];
     }
 
@@ -132,14 +130,14 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
     {
         BOOST_ASSERT(level > 1);
         auto lidx = LevelIDToIndex(level);
-        auto offset = level_data->lidx_to_children_offsets[lidx];
+        auto offset = level_data.lidx_to_children_offsets[lidx];
         return cell_to_children[offset + cell + 1];
     }
 
-    friend void serialization::read<Ownership>(storage::io::FileReader &reader,
-                                               MultiLevelPartitionImpl &mlp);
-    friend void serialization::write<Ownership>(storage::io::FileWriter &writer,
-                                                const MultiLevelPartitionImpl &mlp);
+    friend void io::read<UseShareMemory>(const boost::filesystem::path &file,
+                                         MultiLevelPartitionImpl &mlp);
+    friend void io::write<UseShareMemory>(const boost::filesystem::path &file,
+                                          const MultiLevelPartitionImpl &mlp);
 
   private:
     auto MakeLevelData(const std::vector<std::uint32_t> &lidx_to_num_cells)
@@ -148,7 +146,7 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
         auto offsets = MakeLevelOffsets(lidx_to_num_cells);
         auto masks = MakeLevelMasks(offsets, num_level);
         auto bits = MakeBitToLevel(offsets, num_level);
-        return std::make_unique<LevelData>(LevelData{num_level, offsets, masks, bits, {0}});
+        return LevelData{num_level, offsets, masks, bits, {0}};
     }
 
     inline std::size_t LevelIDToIndex(LevelID l) const { return l - 1; }
@@ -162,8 +160,8 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
     {
         auto lidx = LevelIDToIndex(l);
 
-        auto shifted_id = cell_id << level_data->lidx_to_offset[lidx];
-        auto cleared_cell = partition[node] & ~level_data->lidx_to_mask[lidx];
+        auto shifted_id = cell_id << level_data.lidx_to_offset[lidx];
+        auto cleared_cell = partition[node] & ~level_data.lidx_to_mask[lidx];
         partition[node] = cleared_cell | shifted_id;
     }
 
@@ -291,13 +289,13 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
             level--;
         }
 
-        level_data->lidx_to_children_offsets[0] = 0;
+        level_data.lidx_to_children_offsets[0] = 0;
 
         for (auto level_idx = 0UL; level_idx < partitions.size() - 1; ++level_idx)
         {
             const auto &parent_partition = partitions[level_idx + 1];
 
-            level_data->lidx_to_children_offsets[level_idx + 1] = cell_to_children.size();
+            level_data.lidx_to_children_offsets[level_idx + 1] = cell_to_children.size();
 
             CellID last_parent_id = parent_partition[permutation.front()];
             cell_to_children.push_back(GetCell(level_idx + 1, permutation.front()));
@@ -316,22 +314,11 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
         }
     }
 
-    LevelDataPtr level_data = {};
+    //! this is always owned by this class because it is so small
+    LevelData level_data;
     Vector<PartitionID> partition;
     Vector<CellID> cell_to_children;
 };
-
-template <>
-inline MultiLevelPartitionImpl<storage::Ownership::Container>::MultiLevelPartitionImpl()
-    : level_data(std::make_unique<LevelData>())
-{
-}
-
-template <>
-inline MultiLevelPartitionImpl<storage::Ownership::View>::MultiLevelPartitionImpl()
-    : level_data(nullptr)
-{
-}
 }
 }
 }

include/partition/serialization.hpp

@@ -1,78 +0,0 @@
-#ifndef OSRM_PARTITION_SERIALIZATION_HPP
-#define OSRM_PARTITION_SERIALIZATION_HPP
-
-#include "partition/cell_storage.hpp"
-#include "partition/edge_based_graph.hpp"
-#include "partition/multi_level_graph.hpp"
-#include "partition/multi_level_partition.hpp"
-
-#include "storage/io.hpp"
-#include "storage/serialization.hpp"
-#include "storage/shared_memory_ownership.hpp"
-
-namespace osrm
-{
-namespace partition
-{
-namespace serialization
-{
-
-template <typename EdgeDataT, storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader, MultiLevelGraph<EdgeDataT, Ownership> &graph)
-{
-    storage::serialization::read(reader, graph.node_array);
-    storage::serialization::read(reader, graph.edge_array);
-    storage::serialization::read(reader, graph.node_to_edge_offset);
-}
-
-template <typename EdgeDataT, storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer,
-                  const MultiLevelGraph<EdgeDataT, Ownership> &graph)
-{
-    storage::serialization::write(writer, graph.node_array);
-    storage::serialization::write(writer, graph.edge_array);
-    storage::serialization::write(writer, graph.node_to_edge_offset);
-}
-
-template <storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader, detail::MultiLevelPartitionImpl<Ownership> &mlp)
-{
-    reader.ReadInto(*mlp.level_data);
-    storage::serialization::read(reader, mlp.partition);
-    storage::serialization::read(reader, mlp.cell_to_children);
-}
-
-template <storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer,
-                  const detail::MultiLevelPartitionImpl<Ownership> &mlp)
-{
-    writer.WriteOne(*mlp.level_data);
-    storage::serialization::write(writer, mlp.partition);
-    storage::serialization::write(writer, mlp.cell_to_children);
-}
-
-template <storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader, detail::CellStorageImpl<Ownership> &storage)
-{
-    storage::serialization::read(reader, storage.weights);
-    storage::serialization::read(reader, storage.source_boundary);
-    storage::serialization::read(reader, storage.destination_boundary);
-    storage::serialization::read(reader, storage.cells);
-    storage::serialization::read(reader, storage.level_to_cell_offset);
-}
-
-template <storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer,
-                  const detail::CellStorageImpl<Ownership> &storage)
-{
-    storage::serialization::write(writer, storage.weights);
-    storage::serialization::write(writer, storage.source_boundary);
-    storage::serialization::write(writer, storage.destination_boundary);
-    storage::serialization::write(writer, storage.cells);
-    storage::serialization::write(writer, storage.level_to_cell_offset);
-}
-}
-}
-}
-
-#endif

include/storage/io.hpp

@@ -128,6 +128,20 @@ class FileReader
     std::uint32_t ReadElementCount32() { return ReadOne<std::uint32_t>(); }
     std::uint64_t ReadElementCount64() { return ReadOne<std::uint64_t>(); }
 
+    template <typename T> void DeserializeVector(std::vector<T> &data)
+    {
+        const auto count = ReadElementCount64();
+        data.resize(count);
+        ReadInto(data.data(), count);
+    }
+
+    template <typename T> std::size_t GetVectorMemorySize()
+    {
+        const auto count = ReadElementCount64();
+        Skip<T>(count);
+        return sizeof(count) + sizeof(T) * count;
+    }
+
     template <typename T> std::size_t ReadVectorSize()
     {
         const auto count = ReadElementCount64();
@@ -135,6 +149,19 @@ class FileReader
         return count;
     }
 
+    template <typename T> void *DeserializeVector(void *begin, const void *end)
+    {
+        auto count = ReadElementCount64();
+        auto required = reinterpret_cast<char *>(begin) + sizeof(count) + sizeof(T) * count;
+        if (required > end)
+            throw util::exception("Not enough memory ");
+
+        *reinterpret_cast<decltype(count) *>(begin) = count;
+        ReadInto(reinterpret_cast<T *>(reinterpret_cast<char *>(begin) + sizeof(decltype(count))),
+                 count);
+        return required;
+    }
+
     bool ReadAndCheckFingerprint()
     {
         auto loaded_fingerprint = ReadOne<util::FingerPrint>();
@@ -172,6 +199,42 @@ class FileReader
         input_stream.seekg(current_pos, input_stream.beg);
         return length;
     }
+
+    std::vector<std::string> ReadLines()
+    {
+        std::vector<std::string> result;
+        std::string thisline;
+        try
+        {
+            while (std::getline(input_stream, thisline))
+            {
+                result.push_back(thisline);
+            }
+        }
+        catch (const std::ios_base::failure &)
+        {
+            // EOF is OK here, everything else, re-throw
+            if (!input_stream.eof())
+                throw;
+        }
+        return result;
+    }
+
+    std::string ReadLine()
+    {
+        std::string thisline;
+        try
+        {
+            std::getline(input_stream, thisline);
+        }
+        catch (const std::ios_base::failure & /*e*/)
+        {
+            // EOF is OK here, everything else, re-throw
+            if (!input_stream.eof())
+                throw;
+        }
+        return thisline;
+    }
 };
 
 class FileWriter
@@ -233,6 +296,13 @@ class FileWriter
     void WriteElementCount32(const std::uint32_t count) { WriteOne<std::uint32_t>(count); }
     void WriteElementCount64(const std::uint64_t count) { WriteOne<std::uint64_t>(count); }
 
+    template <typename T> void SerializeVector(const std::vector<T> &data)
+    {
+        const auto count = data.size();
+        WriteElementCount64(count);
+        return WriteFrom(data.data(), count);
+    }
+
     void WriteFingerprint()
     {
         const auto fingerprint = util::FingerPrint::GetValid();

include/storage/io_fwd.hpp

@@ -1,18 +0,0 @@
-#ifndef OSRM_STORAGE_IO_FWD_HPP_
-#define OSRM_STORAGE_IO_FWD_HPP_
-
-namespace osrm
-{
-namespace storage
-{
-namespace io
-{
-
-class FileReader;
-class FileWriter;
-
-} // ns io
-} // ns storage
-} // ns osrm
-
-#endif

include/storage/serialization.hpp

@@ -1,9 +1,23 @@
-#ifndef OSRM_STORAGE_SERIALIZATION_HPP
-#define OSRM_STORAGE_SERIALIZATION_HPP
-
-#include "util/vector_view.hpp"
+#ifndef OSRM_STORAGE_SERIALIZATION_HPP_
+#define OSRM_STORAGE_SERIALIZATION_HPP_
 
+#include "contractor/query_edge.hpp"
+#include "extractor/extractor.hpp"
+#include "extractor/original_edge_data.hpp"
+#include "extractor/query_node.hpp"
 #include "storage/io.hpp"
+#include "util/exception.hpp"
+#include "util/fingerprint.hpp"
+#include "util/log.hpp"
+#include "util/static_graph.hpp"
+
+#include <boost/filesystem/fstream.hpp>
+#include <boost/iostreams/seek.hpp>
+
+#include <cerrno>
+#include <cstring>
+#include <tuple>
+#include <type_traits>
 
 namespace osrm
 {
@@ -12,32 +26,103 @@ namespace storage
 namespace serialization
 {
 
-template <typename T> void read(io::FileReader &reader, std::vector<T> &data)
+// To make function calls consistent, this function returns the fixed number of properties
+inline std::size_t readPropertiesCount() { return 1; }
+
+struct HSGRHeader
 {
-    const auto count = reader.ReadElementCount64();
-    data.resize(count);
-    reader.ReadInto(data.data(), count);
+    std::uint32_t checksum;
+    std::uint64_t number_of_nodes;
+    std::uint64_t number_of_edges;
+};
+
+// Reads the checksum, number of nodes and number of edges written in the header file of a `.hsgr`
+// file and returns them in a HSGRHeader struct
+inline HSGRHeader readHSGRHeader(io::FileReader &input_file)
+{
+
+    HSGRHeader header;
+    input_file.ReadInto(header.checksum);
+    input_file.ReadInto(header.number_of_nodes);
+    input_file.ReadInto(header.number_of_edges);
+
+    // If we have edges, then we must have nodes.
+    // However, there can be nodes with no edges (some test cases create this)
+    BOOST_ASSERT_MSG(header.number_of_edges == 0 || header.number_of_nodes > 0,
+                     "edges exist, but there are no nodes");
+
+    return header;
 }
 
-template <typename T> void write(io::FileWriter &writer, const std::vector<T> &data)
+// Reads the graph data of a `.hsgr` file into memory
+// Needs to be called after readHSGRHeader() to get the correct offset in the stream
+using NodeT = typename util::StaticGraph<contractor::QueryEdge::EdgeData>::NodeArrayEntry;
+using EdgeT = typename util::StaticGraph<contractor::QueryEdge::EdgeData>::EdgeArrayEntry;
+inline void readHSGR(io::FileReader &input_file,
+                     NodeT *node_buffer,
+                     const std::uint64_t number_of_nodes,
+                     EdgeT *edge_buffer,
+                     const std::uint64_t number_of_edges)
 {
-    const auto count = data.size();
-    writer.WriteElementCount64(count);
-    return writer.WriteFrom(data.data(), count);
+    BOOST_ASSERT(node_buffer);
+    BOOST_ASSERT(edge_buffer);
+    input_file.ReadInto(node_buffer, number_of_nodes);
+    input_file.ReadInto(edge_buffer, number_of_edges);
 }
 
-template <typename T> void read(io::FileReader &reader, util::vector_view<T> &data)
+// Loads edge data from .edge files into memory which includes its
+// geometry, name ID, turn instruction, lane data ID, travel mode, entry class ID
+// Needs to be called after readElementCount() to get the correct offset in the stream
+inline void readEdges(io::FileReader &edges_input_file,
+                      GeometryID *geometry_list,
+                      NameID *name_id_list,
+                      extractor::guidance::TurnInstruction *turn_instruction_list,
+                      LaneDataID *lane_data_id_list,
+                      extractor::TravelMode *travel_mode_list,
+                      EntryClassID *entry_class_id_list,
+                      util::guidance::TurnBearing *pre_turn_bearing_list,
+                      util::guidance::TurnBearing *post_turn_bearing_list,
+                      const std::uint64_t number_of_edges)
 {
-    const auto count = reader.ReadElementCount64();
-    BOOST_ASSERT(data.size() == count);
-    reader.ReadInto(data.data(), count);
+    BOOST_ASSERT(geometry_list);
+    BOOST_ASSERT(name_id_list);
+    BOOST_ASSERT(turn_instruction_list);
+    BOOST_ASSERT(lane_data_id_list);
+    BOOST_ASSERT(travel_mode_list);
+    BOOST_ASSERT(entry_class_id_list);
+    extractor::OriginalEdgeData current_edge_data;
+    for (std::uint64_t i = 0; i < number_of_edges; ++i)
+    {
+        edges_input_file.ReadInto(current_edge_data);
+
+        geometry_list[i] = current_edge_data.via_geometry;
+        name_id_list[i] = current_edge_data.name_id;
+        turn_instruction_list[i] = current_edge_data.turn_instruction;
+        lane_data_id_list[i] = current_edge_data.lane_data_id;
+        travel_mode_list[i] = current_edge_data.travel_mode;
+        entry_class_id_list[i] = current_edge_data.entry_classid;
+        pre_turn_bearing_list[i] = current_edge_data.pre_turn_bearing;
+        post_turn_bearing_list[i] = current_edge_data.post_turn_bearing;
+    }
 }
 
-template <typename T> void write(io::FileWriter &writer, const util::vector_view<T> &data)
+// Loads coordinates and OSM node IDs from .nodes files into memory
+// Needs to be called after readElementCount() to get the correct offset in the stream
+template <typename OSMNodeIDVectorT>
+void readNodes(io::FileReader &nodes_file,
+               util::Coordinate *coordinate_list,
+               OSMNodeIDVectorT &osmnodeid_list,
+               const std::uint64_t number_of_coordinates)
 {
-    const auto count = data.size();
-    writer.WriteElementCount64(count);
-    return writer.WriteFrom(data.data(), count);
+    BOOST_ASSERT(coordinate_list);
+    extractor::QueryNode current_node;
+    for (std::uint64_t i = 0; i < number_of_coordinates; ++i)
+    {
+        nodes_file.ReadInto(current_node);
+        coordinate_list[i] = util::Coordinate(current_node.lon, current_node.lat);
+        osmnodeid_list.push_back(current_node.node_id);
+        BOOST_ASSERT(coordinate_list[i].IsValid());
+    }
 }
 }
 }

include/storage/shared_memory.hpp

@@ -25,8 +25,6 @@
 #include <exception>
 #include <thread>
 
-#include "storage/shared_memory_ownership.hpp"
-
 namespace osrm
 {
 namespace storage

include/storage/shared_memory_ownership.hpp

@@ -1,17 +0,0 @@
-#ifndef SHARED_MEMORY_OWNERSHIP_HPP
-#define SHARED_MEMORY_OWNERSHIP_HPP
-
-namespace osrm
-{
-namespace storage
-{
-
-enum class Ownership
-{
-    Container,
-    View
-};
-}
-}
-
-#endif // SHARED_MEMORY_OWNERSHIP_HPP

include/util/binary_heap.hpp

@@ -16,48 +16,6 @@ namespace osrm
 namespace util
 {
 
-template <typename NodeID, typename Key> class GenerationArrayStorage
-{
-    using GenerationCounter = std::uint16_t;
-
-  public:
-    explicit GenerationArrayStorage(std::size_t size)
-        : positions(size, 0), generation(1), generations(size, 0)
-    {
-    }
-
-    Key &operator[](NodeID node)
-    {
-        generation[node] = generation;
-        return positions[node];
-    }
-
-    Key peek_index(const NodeID node) const
-    {
-        if (generations[node] < generation)
-        {
-            return std::numeric_limits<Key>::max();
-        }
-        return positions[node];
-    }
-
-    void Clear()
-    {
-        generation++;
-        // if generation overflows we end up at 0 again and need to clear the vector
-        if (generation == 0)
-        {
-            generation = 1;
-            std::fill(generations.begin(), generations.end(), 0);
-        }
-    }
-
-  private:
-    GenerationCounter generation;
-    std::vector<GenerationCounter> generations;
-    std::vector<Key> positions;
-};
-
 template <typename NodeID, typename Key> class ArrayStorage
 {
   public:
@@ -134,6 +92,10 @@ template <typename NodeID,
           typename IndexStorage = ArrayStorage<NodeID, NodeID>>
 class BinaryHeap
 {
+  private:
+    BinaryHeap(const BinaryHeap &right);
+    void operator=(const BinaryHeap &right);
+
   public:
     using WeightType = Weight;
     using DataType = Data;

include/util/deallocating_vector.hpp

@@ -239,13 +239,6 @@ class DeallocatingVector
         bucket_list.emplace_back(new ElementT[ELEMENTS_PER_BLOCK]);
     }
 
-    // copying is not safe since this would only do a shallow copy
-    DeallocatingVector(DeallocatingVector &other) = delete;
-    DeallocatingVector &operator=(DeallocatingVector &other) = delete;
-    // moving is fine
-    DeallocatingVector(DeallocatingVector &&other) = default;
-    DeallocatingVector &operator=(DeallocatingVector &&other) = default;
-
     ~DeallocatingVector() { clear(); }
 
     friend void swap<>(DeallocatingVector<ElementT, ELEMENTS_PER_BLOCK> &lhs,

include/util/dynamic_graph.hpp

@@ -5,8 +5,6 @@
 #include "util/integer_range.hpp"
 #include "util/typedefs.hpp"
 
-#include "storage/io_fwd.hpp"
-
 #include <boost/assert.hpp>
 
 #include <cstdint>
@@ -21,16 +19,6 @@ namespace osrm
 {
 namespace util
 {
-template <typename EdgeDataT> class DynamicGraph;
-
-namespace serialization
-{
-template <typename EdgeDataT, bool UseSharedMemory>
-void read(storage::io::FileReader &reader, DynamicGraph<EdgeDataT> &graph);
-
-template <typename EdgeDataT, bool UseSharedMemory>
-void write(storage::io::FileWriter &writer, const DynamicGraph<EdgeDataT> &graph);
-}
 
 template <typename EdgeDataT> class DynamicGraph
 {

include/util/graph_loader.hpp

@@ -9,7 +9,6 @@
 #include "util/exception.hpp"
 #include "util/fingerprint.hpp"
 #include "util/log.hpp"
-#include "util/packed_vector.hpp"
 #include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
@@ -58,23 +57,21 @@ template <typename BarrierOutIter, typename TrafficSignalsOutIter>
 NodeID loadNodesFromFile(storage::io::FileReader &file_reader,
                          BarrierOutIter barriers,
                          TrafficSignalsOutIter traffic_signals,
-                         std::vector<util::Coordinate> &coordinates,
-                         util::PackedVector<OSMNodeID> &osm_node_ids)
+                         std::vector<extractor::QueryNode> &node_array)
 {
     NodeID number_of_nodes = file_reader.ReadElementCount32();
     Log() << "Importing number_of_nodes new = " << number_of_nodes << " nodes ";
 
-    coordinates.resize(number_of_nodes);
-    osm_node_ids.reserve(number_of_nodes);
+    node_array.resize(number_of_nodes);
 
     extractor::ExternalMemoryNode current_node;
     for (NodeID i = 0; i < number_of_nodes; ++i)
     {
         file_reader.ReadInto(&current_node, 1);
 
-        coordinates[i].lon = current_node.lon;
-        coordinates[i].lat = current_node.lat;
-        osm_node_ids.push_back(current_node.node_id);
+        node_array[i].lon = current_node.lon;
+        node_array[i].lat = current_node.lat;
+        node_array[i].node_id = current_node.node_id;
 
         if (current_node.barrier)
         {

include/util/io.hpp

@@ -0,0 +1,46 @@
+#ifndef OSRM_INCLUDE_UTIL_IO_HPP_
+#define OSRM_INCLUDE_UTIL_IO_HPP_
+
+#include "util/log.hpp"
+
+#include <boost/filesystem.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <cstddef>
+#include <cstdint>
+
+#include <bitset>
+#include <fstream>
+#include <stxxl/vector>
+#include <vector>
+
+#include "storage/io.hpp"
+#include "util/fingerprint.hpp"
+
+namespace osrm
+{
+namespace util
+{
+
+template <typename simple_type>
+void deserializeAdjacencyArray(const std::string &filename,
+                               std::vector<std::uint32_t> &offsets,
+                               std::vector<simple_type> &data)
+{
+    storage::io::FileReader file(filename, storage::io::FileReader::HasNoFingerprint);
+
+    file.DeserializeVector(offsets);
+    file.DeserializeVector(data);
+
+    // offsets have to match up with the size of the data
+    if (offsets.empty() || (offsets.back() != boost::numeric_cast<std::uint32_t>(data.size())))
+        throw util::exception(
+            "Error in " + filename +
+            (offsets.empty() ? "Offsets are empty" : "Offset and data size do not match") +
+            SOURCE_REF);
+}
+
+} // namespace util
+} // namespace osrm
+
+#endif // OSRM_INCLUDE_UTIL_IO_HPP_

include/util/name_table.hpp

@@ -2,6 +2,7 @@
 #define OSRM_UTIL_NAME_TABLE_HPP
 
 #include "util/indexed_data.hpp"
+#include "util/shared_memory_vector_wrapper.hpp"
 #include "util/string_view.hpp"
 #include "util/typedefs.hpp"
 

include/util/packed_vector.hpp

@@ -1,11 +1,8 @@
 #ifndef PACKED_VECTOR_HPP
 #define PACKED_VECTOR_HPP
 
+#include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"
-#include "util/vector_view.hpp"
-
-#include "storage/io_fwd.hpp"
-#include "storage/shared_memory_ownership.hpp"
 
 #include <cmath>
 #include <vector>
@@ -14,22 +11,7 @@ namespace osrm
 {
 namespace util
 {
-namespace detail
-{
-template <typename T, storage::Ownership Ownership> class PackedVector;
-}
 
-namespace serialization
-{
-template <typename T, storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader, detail::PackedVector<T, Ownership> &vec);
-
-template <typename T, storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer, const detail::PackedVector<T, Ownership> &vec);
-}
-
-namespace detail
-{
 /**
  * Since OSM node IDs are (at the time of writing) not quite yet overflowing 32 bits, and
  * will predictably be containable within 33 bits for a long time, the following packs
@@ -38,15 +20,13 @@ namespace detail
  * NOTE: this type is templated for future use, but will require a slight refactor to
  * configure BITSIZE and ELEMSIZE
  */
-template <typename T, storage::Ownership Ownership> class PackedVector
+template <typename T, bool UseSharedMemory = false> class PackedVector
 {
     static const constexpr std::size_t BITSIZE = 33;
     static const constexpr std::size_t ELEMSIZE = 64;
     static const constexpr std::size_t PACKSIZE = BITSIZE * ELEMSIZE;
 
   public:
-    using value_type = T;
-
     /**
      * Returns the size of the packed vector datastructure with `elements` packed elements (the size
      * of
@@ -97,9 +77,7 @@ template <typename T, storage::Ownership Ownership> class PackedVector
         num_elements++;
     }
 
-    T operator[](const std::size_t index) const { return at(index); }
-
-    T at(const std::size_t a_index) const
+    T at(const std::size_t &a_index) const
     {
         BOOST_ASSERT(a_index < num_elements);
 
@@ -142,20 +120,20 @@ template <typename T, storage::Ownership Ownership> class PackedVector
 
     std::size_t size() const { return num_elements; }
 
-    template <bool enabled = (Ownership == storage::Ownership::View)>
+    template <bool enabled = UseSharedMemory>
     void reserve(typename std::enable_if<!enabled, std::size_t>::type capacity)
     {
         vec.reserve(elements_to_blocks(capacity));
     }
 
-    template <bool enabled = (Ownership == storage::Ownership::View)>
+    template <bool enabled = UseSharedMemory>
     void reset(typename std::enable_if<enabled, std::uint64_t>::type *ptr,
                typename std::enable_if<enabled, std::size_t>::type size)
     {
         vec.reset(ptr, size);
     }
 
-    template <bool enabled = (Ownership == storage::Ownership::View)>
+    template <bool enabled = UseSharedMemory>
     void set_number_of_entries(typename std::enable_if<enabled, std::size_t>::type count)
     {
         num_elements = count;
@@ -166,61 +144,51 @@ template <typename T, storage::Ownership Ownership> class PackedVector
         return std::floor(static_cast<double>(vec.capacity()) * ELEMSIZE / BITSIZE);
     }
 
-    friend void serialization::read<T, Ownership>(storage::io::FileReader &reader,
-                                                  detail::PackedVector<T, Ownership> &vec);
-
-    friend void serialization::write<T, Ownership>(storage::io::FileWriter &writer,
-                                                   const detail::PackedVector<T, Ownership> &vec);
-
   private:
-    util::ViewOrVector<std::uint64_t, Ownership> vec;
+    typename util::ShM<std::uint64_t, UseSharedMemory>::vector vec;
 
-    std::uint64_t num_elements = 0;
+    std::size_t num_elements = 0;
 
     signed cursor = -1;
 
-    template <bool enabled = (Ownership == storage::Ownership::View)>
+    template <bool enabled = UseSharedMemory>
     void replace_last_elem(typename std::enable_if<enabled, std::uint64_t>::type last_elem)
     {
         vec[cursor] = last_elem;
     }
 
-    template <bool enabled = (Ownership == storage::Ownership::View)>
+    template <bool enabled = UseSharedMemory>
     void replace_last_elem(typename std::enable_if<!enabled, std::uint64_t>::type last_elem)
     {
         vec.back() = last_elem;
     }
 
-    template <bool enabled = (Ownership == storage::Ownership::View)>
+    template <bool enabled = UseSharedMemory>
     void add_last_elem(typename std::enable_if<enabled, std::uint64_t>::type last_elem)
     {
         vec[cursor + 1] = last_elem;
         cursor++;
     }
 
-    template <bool enabled = (Ownership == storage::Ownership::View)>
+    template <bool enabled = UseSharedMemory>
     void add_last_elem(typename std::enable_if<!enabled, std::uint64_t>::type last_elem)
     {
         vec.push_back(last_elem);
     }
 
-    template <bool enabled = (Ownership == storage::Ownership::View)>
+    template <bool enabled = UseSharedMemory>
     std::uint64_t vec_back(typename std::enable_if<enabled>::type * = nullptr)
     {
         return vec[cursor];
     }
 
-    template <bool enabled = (Ownership == storage::Ownership::View)>
+    template <bool enabled = UseSharedMemory>
     std::uint64_t vec_back(typename std::enable_if<!enabled>::type * = nullptr)
     {
         return vec.back();
     }
 };
 }
-
-template <typename T> using PackedVector = detail::PackedVector<T, storage::Ownership::Container>;
-template <typename T> using PackedVectorView = detail::PackedVector<T, storage::Ownership::View>;
-}
 }
 
 #endif /* PACKED_VECTOR_HPP */

include/util/range_table.hpp

@@ -2,9 +2,8 @@
 #define RANGE_TABLE_HPP
 
 #include "storage/io.hpp"
-#include "storage/shared_memory_ownership.hpp"
 #include "util/integer_range.hpp"
-#include "util/vector_view.hpp"
+#include "util/shared_memory_vector_wrapper.hpp"
 
 #include <array>
 #include <fstream>
@@ -19,14 +18,13 @@ namespace util
  * and otherwise the compiler gets confused.
  */
 
-template <unsigned BLOCK_SIZE = 16, storage::Ownership Ownership = storage::Ownership::Container>
-class RangeTable;
+template <unsigned BLOCK_SIZE = 16, bool USE_SHARED_MEMORY = false> class RangeTable;
 
-template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
-std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, Ownership> &table);
+template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
+std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table);
 
-template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
-std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, Ownership> &table);
+template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
+std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table);
 
 /**
  * Stores adjacent ranges in a compressed format.
@@ -37,12 +35,12 @@ std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, Ownership> &ta
  * But each block consists of an absolute value and BLOCK_SIZE differential values.
  * So the effective block size is sizeof(unsigned) + BLOCK_SIZE.
  */
-template <unsigned BLOCK_SIZE, storage::Ownership Ownership> class RangeTable
+template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
 {
   public:
     using BlockT = std::array<unsigned char, BLOCK_SIZE>;
-    using BlockContainerT = util::ViewOrVector<BlockT, Ownership>;
-    using OffsetContainerT = util::ViewOrVector<unsigned, Ownership>;
+    using BlockContainerT = typename ShM<BlockT, USE_SHARED_MEMORY>::vector;
+    using OffsetContainerT = typename ShM<unsigned, USE_SHARED_MEMORY>::vector;
     using RangeT = range<unsigned>;
 
     friend std::ostream &operator<<<>(std::ostream &out, const RangeTable &table);
@@ -141,7 +139,7 @@ template <unsigned BLOCK_SIZE, storage::Ownership Ownership> class RangeTable
         sum_lengths = lengths_prefix_sum;
     }
 
-    void Write(storage::io::FileWriter &filewriter)
+    void Write(osrm::storage::io::FileWriter &filewriter)
     {
         unsigned number_of_blocks = diff_blocks.size();
 
@@ -153,7 +151,7 @@ template <unsigned BLOCK_SIZE, storage::Ownership Ownership> class RangeTable
         filewriter.WriteFrom(diff_blocks.data(), number_of_blocks);
     }
 
-    void Read(storage::io::FileReader &filereader)
+    void Read(osrm::storage::io::FileReader &filereader)
     {
         unsigned number_of_blocks = filereader.ReadElementCount32();
         // read total length
@@ -214,8 +212,9 @@ template <unsigned BLOCK_SIZE, storage::Ownership Ownership> class RangeTable
     unsigned sum_lengths;
 };
 
-template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
-unsigned RangeTable<BLOCK_SIZE, Ownership>::PrefixSumAtIndex(int index, const BlockT &block) const
+template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
+unsigned RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY>::PrefixSumAtIndex(int index,
+                                                                     const BlockT &block) const
 {
     // this loop looks inefficent, but a modern compiler
     // will emit nice SIMD here, at least for sensible block sizes. (I checked.)
@@ -228,8 +227,8 @@ unsigned RangeTable<BLOCK_SIZE, Ownership>::PrefixSumAtIndex(int index, const Bl
     return sum;
 }
 
-template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
-std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, Ownership> &table)
+template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
+std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table)
 {
     // write number of block
     const unsigned number_of_blocks = table.diff_blocks.size();
@@ -244,8 +243,8 @@ std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, Ownersh
     return out;
 }
 
-template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
-std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, Ownership> &table)
+template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
+std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table)
 {
     // read number of block
     unsigned number_of_blocks;

include/util/serialization.hpp

@@ -1,73 +0,0 @@
-#ifndef OSMR_UTIL_SERIALIZATION_HPP
-#define OSMR_UTIL_SERIALIZATION_HPP
-
-#include "util/dynamic_graph.hpp"
-#include "util/packed_vector.hpp"
-#include "util/static_graph.hpp"
-
-#include "storage/io.hpp"
-#include "storage/serialization.hpp"
-
-namespace osrm
-{
-namespace util
-{
-namespace serialization
-{
-template <typename T, storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader, detail::PackedVector<T, Ownership> &vec)
-{
-    vec.num_elements = reader.ReadOne<std::uint64_t>();
-    storage::serialization::read(reader, vec.vec);
-}
-
-template <typename T, storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer, const detail::PackedVector<T, Ownership> &vec)
-{
-    writer.WriteOne(vec.num_elements);
-    storage::serialization::write(writer, vec.vec);
-}
-
-template <typename EdgeDataT, storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader, StaticGraph<EdgeDataT, Ownership> &graph)
-{
-    storage::serialization::read(reader, graph.node_array);
-    storage::serialization::read(reader, graph.edge_array);
-}
-
-template <typename EdgeDataT, storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer, const StaticGraph<EdgeDataT, Ownership> &graph)
-{
-    storage::serialization::write(writer, graph.node_array);
-    storage::serialization::write(writer, graph.edge_array);
-}
-
-template <typename EdgeDataT>
-inline void read(storage::io::FileReader &reader, DynamicGraph<EdgeDataT> &graph)
-{
-    storage::serialization::read(reader, graph.node_array);
-    auto num_edges = reader.ReadElementCount64();
-    graph.edge_list.resize(num_edges);
-    for (auto index : irange<std::size_t>(0, num_edges))
-    {
-        reader.ReadOne(graph.edge_list[index]);
-    }
-    graph.number_of_nodes = graph.node_array.size();
-    graph.number_of_edges = num_edges;
-}
-
-template <typename EdgeDataT>
-inline void write(storage::io::FileWriter &writer, const DynamicGraph<EdgeDataT> &graph)
-{
-    storage::serialization::write(writer, graph.node_array);
-    writer.WriteElementCount64(graph.number_of_edges);
-    for (auto index : irange<std::size_t>(0, graph.number_of_edges))
-    {
-        writer.WriteOne(graph.edge_list[index]);
-    }
-}
-}
-}
-}
-
-#endif

include/util/shared_memory_vector_wrapper.hpp

@@ -1,11 +1,8 @@
-#ifndef UTIL_VECTOR_VIEW_HPP
-#define UTIL_VECTOR_VIEW_HPP
+#ifndef SHARED_MEMORY_VECTOR_WRAPPER_HPP
+#define SHARED_MEMORY_VECTOR_WRAPPER_HPP
 
-#include "util/exception.hpp"
 #include "util/log.hpp"
 
-#include "storage/shared_memory_ownership.hpp"
-
 #include <boost/assert.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
@@ -25,13 +22,10 @@ namespace util
 {
 
 template <typename DataT>
-class VectorViewIterator : public boost::iterator_facade<VectorViewIterator<DataT>,
-                                                         DataT,
-                                                         boost::random_access_traversal_tag>
+class ShMemIterator
+    : public boost::iterator_facade<ShMemIterator<DataT>, DataT, boost::random_access_traversal_tag>
 {
-    typedef boost::iterator_facade<VectorViewIterator<DataT>,
-                                   DataT,
-                                   boost::random_access_traversal_tag>
+    typedef boost::iterator_facade<ShMemIterator<DataT>, DataT, boost::random_access_traversal_tag>
         base_t;
 
   public:
@@ -40,16 +34,16 @@ class VectorViewIterator : public boost::iterator_facade<VectorViewIterator<Data
     typedef typename base_t::reference reference;
     typedef std::random_access_iterator_tag iterator_category;
 
-    explicit VectorViewIterator() : m_value(nullptr) {}
-    explicit VectorViewIterator(DataT *x) : m_value(x) {}
+    explicit ShMemIterator() : m_value(nullptr) {}
+    explicit ShMemIterator(DataT *x) : m_value(x) {}
 
   private:
     void increment() { ++m_value; }
     void decrement() { --m_value; }
     void advance(difference_type offset) { m_value += offset; }
-    bool equal(const VectorViewIterator &other) const { return m_value == other.m_value; }
+    bool equal(const ShMemIterator &other) const { return m_value == other.m_value; }
     reference dereference() const { return *m_value; }
-    difference_type distance_to(const VectorViewIterator &other) const
+    difference_type distance_to(const ShMemIterator &other) const
     {
         return other.m_value - m_value;
     }
@@ -58,7 +52,7 @@ class VectorViewIterator : public boost::iterator_facade<VectorViewIterator<Data
     DataT *m_value;
 };
 
-template <typename DataT> class vector_view
+template <typename DataT> class SharedMemoryWrapper
 {
   private:
     DataT *m_ptr;
@@ -66,13 +60,13 @@ template <typename DataT> class vector_view
 
   public:
     using value_type = DataT;
-    using iterator = VectorViewIterator<DataT>;
-    using const_iterator = VectorViewIterator<const DataT>;
+    using iterator = ShMemIterator<DataT>;
+    using const_iterator = ShMemIterator<const DataT>;
     using reverse_iterator = boost::reverse_iterator<iterator>;
 
-    vector_view() : m_ptr(nullptr), m_size(0) {}
+    SharedMemoryWrapper() : m_ptr(nullptr), m_size(0) {}
 
-    vector_view(DataT *ptr, std::size_t size) : m_ptr(ptr), m_size(size) {}
+    SharedMemoryWrapper(DataT *ptr, std::size_t size) : m_ptr(ptr), m_size(size) {}
 
     void reset(DataT *ptr, std::size_t size)
     {
@@ -132,21 +126,20 @@ template <typename DataT> class vector_view
 
     auto data() const { return m_ptr; }
 
-    template <typename T> friend void swap(vector_view<T> &, vector_view<T> &) noexcept;
+    template <typename T>
+    friend void swap(SharedMemoryWrapper<T> &, SharedMemoryWrapper<T> &) noexcept;
 };
 
-template <> class vector_view<bool>
+template <> class SharedMemoryWrapper<bool>
 {
   private:
     unsigned *m_ptr;
     std::size_t m_size;
 
   public:
-    using value_type = bool;
+    SharedMemoryWrapper() : m_ptr(nullptr), m_size(0) {}
 
-    vector_view() : m_ptr(nullptr), m_size(0) {}
-
-    vector_view(unsigned *ptr, std::size_t size) : m_ptr(ptr), m_size(size) {}
+    SharedMemoryWrapper(unsigned *ptr, std::size_t size) : m_ptr(ptr), m_size(size) {}
 
     bool at(const std::size_t index) const
     {
@@ -156,7 +149,11 @@ template <> class vector_view<bool>
         return m_ptr[bucket] & (1u << offset);
     }
 
-    void reset(unsigned *, std::size_t size) { m_size = size; }
+    void reset(unsigned *ptr, std::size_t size)
+    {
+        m_ptr = ptr;
+        m_size = size;
+    }
 
     std::size_t size() const { return m_size; }
 
@@ -164,20 +161,24 @@ template <> class vector_view<bool>
 
     bool operator[](const unsigned index) const { return at(index); }
 
-    template <typename T> friend void swap(vector_view<T> &, vector_view<T> &) noexcept;
+    template <typename T>
+    friend void swap(SharedMemoryWrapper<T> &, SharedMemoryWrapper<T> &) noexcept;
 };
 
-// Both vector_view<T> and the vector_view<bool> specializations share this impl.
-template <typename DataT> void swap(vector_view<DataT> &lhs, vector_view<DataT> &rhs) noexcept
+// Both SharedMemoryWrapper<T> and the SharedMemoryWrapper<bool> specializations share this impl.
+template <typename DataT>
+void swap(SharedMemoryWrapper<DataT> &lhs, SharedMemoryWrapper<DataT> &rhs) noexcept
 {
     std::swap(lhs.m_ptr, rhs.m_ptr);
     std::swap(lhs.m_size, rhs.m_size);
 }
 
-template <typename DataT, storage::Ownership Ownership>
-using ViewOrVector = typename std::conditional<Ownership == storage::Ownership::View,
-                                               vector_view<DataT>,
-                                               std::vector<DataT>>::type;
+template <typename DataT, bool UseSharedMemory> struct ShM
+{
+    using vector = typename std::conditional<UseSharedMemory,
+                                             SharedMemoryWrapper<DataT>,
+                                             std::vector<DataT>>::type;
+};
 }
 }
 

include/util/static_graph.hpp

@@ -4,11 +4,8 @@
 #include "util/graph_traits.hpp"
 #include "util/integer_range.hpp"
 #include "util/percent.hpp"
+#include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"
-#include "util/vector_view.hpp"
-
-#include "storage/io_fwd.hpp"
-#include "storage/shared_memory_ownership.hpp"
 
 #include <boost/assert.hpp>
 
@@ -22,16 +19,6 @@ namespace osrm
 {
 namespace util
 {
-template <typename EdgeDataT, storage::Ownership Ownership> class StaticGraph;
-
-namespace serialization
-{
-template <typename EdgeDataT, storage::Ownership Ownership>
-void read(storage::io::FileReader &reader, StaticGraph<EdgeDataT, Ownership> &graph);
-
-template <typename EdgeDataT, storage::Ownership Ownership>
-void write(storage::io::FileWriter &writer, const StaticGraph<EdgeDataT, Ownership> &graph);
-}
 
 namespace static_graph_details
 {
@@ -110,11 +97,8 @@ EntryT edgeToEntry(const OtherEdge &from, std::false_type)
 
 } // namespace static_graph_details
 
-template <typename EdgeDataT, storage::Ownership Ownership = storage::Ownership::Container>
-class StaticGraph
+template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
 {
-    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
-
   public:
     using InputEdge = static_graph_details::SortableEdgeWithData<EdgeDataT>;
     using NodeIterator = static_graph_details::NodeIterator;
@@ -130,7 +114,7 @@ class StaticGraph
 
     StaticGraph() {}
 
-    template <typename ContainerT> StaticGraph(const std::uint32_t nodes, const ContainerT &edges)
+    template <typename ContainerT> StaticGraph(const int nodes, const ContainerT &edges)
     {
         BOOST_ASSERT(std::is_sorted(const_cast<ContainerT &>(edges).begin(),
                                     const_cast<ContainerT &>(edges).end()));
@@ -138,7 +122,8 @@ class StaticGraph
         InitializeFromSortedEdgeRange(nodes, edges.begin(), edges.end());
     }
 
-    StaticGraph(Vector<NodeArrayEntry> node_array_, Vector<EdgeArrayEntry> edge_array_)
+    StaticGraph(typename ShM<NodeArrayEntry, UseSharedMemory>::vector node_array_,
+                typename ShM<EdgeArrayEntry, UseSharedMemory>::vector edge_array_)
         : node_array(std::move(node_array_)), edge_array(std::move(edge_array_))
     {
         BOOST_ASSERT(!node_array.empty());
@@ -241,15 +226,11 @@ class StaticGraph
         return current_iterator;
     }
 
-    friend void serialization::read<EdgeDataT, Ownership>(storage::io::FileReader &reader,
-                                                          StaticGraph<EdgeDataT, Ownership> &graph);
-    friend void
-    serialization::write<EdgeDataT, Ownership>(storage::io::FileWriter &writer,
-                                               const StaticGraph<EdgeDataT, Ownership> &graph);
-
+    const NodeArrayEntry &GetNode(const NodeID nid) const { return node_array[nid]; }
+    const EdgeArrayEntry &GetEdge(const EdgeID eid) const { return edge_array[eid]; }
   protected:
     template <typename IterT>
-    void InitializeFromSortedEdgeRange(const std::uint32_t nodes, IterT begin, IterT end)
+    void InitializeFromSortedEdgeRange(const unsigned nodes, IterT begin, IterT end)
     {
         number_of_nodes = nodes;
         number_of_edges = static_cast<EdgeIterator>(std::distance(begin, end));
@@ -263,9 +244,7 @@ class StaticGraph
             unsigned offset = std::distance(begin, iter);
             node_array.push_back(NodeArrayEntry{offset});
         }
-        BOOST_ASSERT_MSG(
-            iter == end,
-            ("Still " + std::to_string(std::distance(iter, end)) + " edges left.").c_str());
+        BOOST_ASSERT(iter == end);
         BOOST_ASSERT(node_array.size() == number_of_nodes + 1);
 
         edge_array.resize(number_of_edges);
@@ -279,8 +258,8 @@ class StaticGraph
     NodeIterator number_of_nodes;
     EdgeIterator number_of_edges;
 
-    Vector<NodeArrayEntry> node_array;
-    Vector<EdgeArrayEntry> edge_array;
+    typename ShM<NodeArrayEntry, UseSharedMemory>::vector node_array;
+    typename ShM<EdgeArrayEntry, UseSharedMemory>::vector edge_array;
 };
 
 } // namespace util

include/util/static_rtree.hpp

@@ -9,14 +9,12 @@
 #include "util/hilbert_value.hpp"
 #include "util/integer_range.hpp"
 #include "util/rectangle.hpp"
+#include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"
-#include "util/vector_view.hpp"
 #include "util/web_mercator.hpp"
 
 #include "osrm/coordinate.hpp"
 
-#include "storage/shared_memory_ownership.hpp"
-
 #include <boost/assert.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
@@ -53,17 +51,16 @@ namespace util
 // All coordinates are pojected first to Web Mercator before the bounding boxes
 // are computed, this means the internal distance metric doesn not represent meters!
 template <class EdgeDataT,
-          storage::Ownership Ownership = storage::Ownership::Container,
+          class CoordinateListT = std::vector<Coordinate>,
+          bool UseSharedMemory = false,
           std::uint32_t BRANCHING_FACTOR = 128,
           std::uint32_t LEAF_PAGE_SIZE = 4096>
 class StaticRTree
 {
-    template <typename T> using Vector = ViewOrVector<T, Ownership>;
-
   public:
     using Rectangle = RectangleInt2D;
     using EdgeData = EdgeDataT;
-    using CoordinateList = Vector<util::Coordinate>;
+    using CoordinateList = CoordinateListT;
 
     static_assert(LEAF_PAGE_SIZE >= sizeof(uint32_t) + sizeof(EdgeDataT), "page size is too small");
     static_assert(((LEAF_PAGE_SIZE - 1) & LEAF_PAGE_SIZE) == 0, "page size is not a power of 2");
@@ -155,22 +152,23 @@ class StaticRTree
         Coordinate fixed_projected_coordinate;
     };
 
-    Vector<TreeNode> m_search_tree;
-    const Vector<Coordinate> &m_coordinate_list;
+    typename ShM<TreeNode, UseSharedMemory>::vector m_search_tree;
+    const CoordinateListT &m_coordinate_list;
 
     boost::iostreams::mapped_file_source m_leaves_region;
     // read-only view of leaves
-    util::vector_view<const LeafNode> m_leaves;
+    typename ShM<const LeafNode, true>::vector m_leaves;
 
   public:
     StaticRTree(const StaticRTree &) = delete;
     StaticRTree &operator=(const StaticRTree &) = delete;
 
+    template <typename CoordinateT>
     // Construct a packed Hilbert-R-Tree with Kamel-Faloutsos algorithm [1]
     explicit StaticRTree(const std::vector<EdgeDataT> &input_data_vector,
                          const std::string &tree_node_filename,
                          const std::string &leaf_node_filename,
-                         const Vector<Coordinate> &coordinate_list)
+                         const std::vector<CoordinateT> &coordinate_list)
         : m_coordinate_list(coordinate_list)
     {
         const uint64_t element_count = input_data_vector.size();
@@ -347,7 +345,7 @@ class StaticRTree
 
     explicit StaticRTree(const boost::filesystem::path &node_file,
                          const boost::filesystem::path &leaf_file,
-                         const Vector<Coordinate> &coordinate_list)
+                         const CoordinateListT &coordinate_list)
         : m_coordinate_list(coordinate_list)
     {
         storage::io::FileReader tree_node_file(node_file,
@@ -364,7 +362,7 @@ class StaticRTree
     explicit StaticRTree(TreeNode *tree_node_ptr,
                          const uint64_t number_of_nodes,
                          const boost::filesystem::path &leaf_file,
-                         const Vector<Coordinate> &coordinate_list)
+                         const CoordinateListT &coordinate_list)
         : m_search_tree(tree_node_ptr, number_of_nodes), m_coordinate_list(coordinate_list)
     {
         MapLeafNodesFile(leaf_file);

lib/index.js

@@ -1,2 +1,2 @@
-var OSRM = module.exports = require('./binding/node_osrm.node').OSRM;
+var OSRM = module.exports = require('./binding/node-osrm.node').OSRM;
 OSRM.version = require('../package.json').version;

package.json

@@ -1,11 +1,11 @@
 {
   "name": "osrm",
-  "version": "5.7.0-latest.5",
+  "version": "5.7.0-latest.1",
   "private": false,
   "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
   "dependencies": {
     "nan": "^2.1.0",
-    "node-cmake": "^2.2.1",
+    "node-cmake": "^1.2.1",
     "node-pre-gyp": "^0.6.34"
   },
   "browserify": {
@@ -19,15 +19,14 @@
     "test": "npm run lint && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify && node ./node_modules/cucumber/bin/cucumber.js features/ -p mld",
     "clean": "rm -rf test/cache",
     "docs": "./scripts/build_api_docs.sh",
-    "install": "node-pre-gyp install --fallback-to-build=false",
-    "nodejs-tests": "make -C test/data && ./lib/binding/osrm-datastore test/data/ch/monaco.osrm && node test/nodejs/index.js | faucet"
+    "install": "node-pre-gyp install --fallback-to-build=false"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/Project-OSRM/osrm-backend.git"
   },
   "author": "Project OSRM Team",
-  "license": "BSD-2-Clause",
+  "license": "BSD 2-Clause",
   "bugs": {
     "url": "https://github.com/Project-OSRM/osrm-backend/issues"
   },
@@ -45,7 +44,6 @@
     "mkdirp": "^0.5.1",
     "aws-sdk": "~2.0.31",
     "tape": "^4.2.2",
-    "faucet": "^0.0.1",
     "node-timeout": "0.0.4",
     "polyline": "^0.2.0",
     "request": "^2.69.0",

profiles/rasterbot.lua

@@ -1,8 +1,6 @@
 api_version = 1
 -- Rasterbot profile
 
-properties.force_split_edges = true
-
 -- Minimalist node_ and way_functions in order to test source_ and segment_functions
 
 function node_function (node, result)
@@ -48,7 +46,7 @@ function segment_function (segment)
   local scaled_duration = segment.duration
 
   if sourceData.datum ~= invalid and targetData.datum ~= invalid then
-    local slope = (targetData.datum - sourceData.datum) / segment.distance
+    local slope = math.abs(sourceData.datum - targetData.datum) / segment.distance
     scaled_weight = scaled_weight / (1.0 - (slope * 5.0))
     scaled_duration = scaled_duration / (1.0 - (slope * 5.0))
     io.write("   slope: " .. slope .. "\n")

scripts/travis/publish.sh

@@ -16,7 +16,7 @@ if [[ ${PUBLISH} == 'On' ]]; then
     # enforce that binary has proper ORIGIN flags so that
     # it can portably find libtbb.so in the same directory
     if [[ $(uname -s) == 'Linux' ]]; then
-        readelf -d ./lib/binding/node_osrm.node > readelf-output.txt
+        readelf -d ./lib/binding/node-osrm.node > readelf-output.txt
         if grep -q 'Flags: ORIGIN' readelf-output.txt; then
             echo "Found ORIGIN flag in readelf output"
             cat readelf-output.txt

src/benchmarks/static_rtree.cpp

@@ -27,12 +27,13 @@ constexpr int32_t WORLD_MIN_LON = -180 * COORDINATE_PRECISION;
 constexpr int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION;
 
 using RTreeLeaf = extractor::EdgeBasedNode;
-using BenchStaticRTree = util::StaticRTree<RTreeLeaf, storage::Ownership::Container>;
+using BenchStaticRTree =
+    util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, false>::vector, false>;
 
 std::vector<util::Coordinate> loadCoordinates(const boost::filesystem::path &nodes_file)
 {
-    storage::io::FileReader nodes_path_file_reader(nodes_file,
-                                                   storage::io::FileReader::HasNoFingerprint);
+    osrm::storage::io::FileReader nodes_path_file_reader(
+        nodes_file, osrm::storage::io::FileReader::HasNoFingerprint);
 
     extractor::QueryNode current_node;
     unsigned coordinate_count = nodes_path_file_reader.ReadElementCount32();

src/contractor/contractor.cpp

@@ -1,6 +1,5 @@
 #include "contractor/contractor.hpp"
 #include "contractor/crc32_processor.hpp"
-#include "contractor/files.hpp"
 #include "contractor/graph_contractor.hpp"
 #include "contractor/graph_contractor_adaptors.hpp"
 
@@ -16,6 +15,7 @@
 #include "util/exception_utils.hpp"
 #include "util/graph_loader.hpp"
 #include "util/integer_range.hpp"
+#include "util/io.hpp"
 #include "util/log.hpp"
 #include "util/static_graph.hpp"
 #include "util/string_util.hpp"
@@ -47,9 +47,9 @@ int Contractor::Run()
     util::Log() << "Reading node weights.";
     std::vector<EdgeWeight> node_weights;
     {
-        storage::io::FileReader reader(config.node_file_path,
-                                       storage::io::FileReader::VerifyFingerprint);
-        storage::serialization::read(reader, node_weights);
+        storage::io::FileReader node_file(config.node_file_path,
+                                          storage::io::FileReader::VerifyFingerprint);
+        node_file.DeserializeVector(node_weights);
     }
     util::Log() << "Done reading node weights.";
 
@@ -85,7 +85,7 @@ int Contractor::Run()
 
     util::Log() << "Contraction took " << TIMER_SEC(contraction) << " sec";
 
-    WriteContractedGraph(max_edge_id, std::move(contracted_edge_list));
+    std::size_t number_of_used_edges = WriteContractedGraph(max_edge_id, contracted_edge_list);
     WriteCoreNodeMarker(std::move(is_core_node));
     if (!config.use_cached_priority)
     {
@@ -94,7 +94,14 @@ int Contractor::Run()
 
     TIMER_STOP(preparing);
 
+    const auto nodes_per_second =
+        static_cast<std::uint64_t>((max_edge_id + 1) / TIMER_SEC(contraction));
+    const auto edges_per_second =
+        static_cast<std::uint64_t>(number_of_used_edges / TIMER_SEC(contraction));
+
     util::Log() << "Preprocessing : " << TIMER_SEC(preparing) << " seconds";
+    util::Log() << "Contraction: " << nodes_per_second << " nodes/sec and " << edges_per_second
+                << " edges/sec";
 
     util::Log() << "finished preprocessing";
 
@@ -115,10 +122,10 @@ void Contractor::WriteNodeLevels(std::vector<float> &&in_node_levels) const
 {
     std::vector<float> node_levels(std::move(in_node_levels));
 
-    storage::io::FileWriter writer(config.level_output_path,
-                                   storage::io::FileWriter::HasNoFingerprint);
+    storage::io::FileWriter node_level_file(config.level_output_path,
+                                            storage::io::FileWriter::HasNoFingerprint);
 
-    storage::serialization::write(writer, node_levels);
+    node_level_file.SerializeVector(node_levels);
 }
 
 void Contractor::WriteCoreNodeMarker(std::vector<bool> &&in_is_core_node) const
@@ -138,20 +145,117 @@ void Contractor::WriteCoreNodeMarker(std::vector<bool> &&in_is_core_node) const
     core_marker_output_file.WriteFrom(unpacked_bool_flags.data(), count);
 }
 
-void Contractor::WriteContractedGraph(unsigned max_node_id,
-                                      util::DeallocatingVector<QueryEdge> contracted_edge_list)
+std::size_t
+Contractor::WriteContractedGraph(unsigned max_node_id,
+                                 const util::DeallocatingVector<QueryEdge> &contracted_edge_list)
 {
     // Sorting contracted edges in a way that the static query graph can read some in in-place.
     tbb::parallel_sort(contracted_edge_list.begin(), contracted_edge_list.end());
-    auto new_end = std::unique(contracted_edge_list.begin(), contracted_edge_list.end());
-    contracted_edge_list.resize(new_end - contracted_edge_list.begin());
+    const std::uint64_t contracted_edge_count = contracted_edge_list.size();
+    util::Log() << "Serializing compacted graph of " << contracted_edge_count << " edges";
+
+    storage::io::FileWriter hsgr_output_file(config.graph_output_path,
+                                             storage::io::FileWriter::GenerateFingerprint);
+
+    const NodeID max_used_node_id = [&contracted_edge_list] {
+        NodeID tmp_max = 0;
+        for (const QueryEdge &edge : contracted_edge_list)
+        {
+            BOOST_ASSERT(SPECIAL_NODEID != edge.source);
+            BOOST_ASSERT(SPECIAL_NODEID != edge.target);
+            tmp_max = std::max(tmp_max, edge.source);
+            tmp_max = std::max(tmp_max, edge.target);
+        }
+        return tmp_max;
+    }();
+
+    util::Log(logDEBUG) << "input graph has " << (max_node_id + 1) << " nodes";
+    util::Log(logDEBUG) << "contracted graph has " << (max_used_node_id + 1) << " nodes";
+
+    std::vector<util::StaticGraph<EdgeData>::NodeArrayEntry> node_array;
+    // make sure we have at least one sentinel
+    node_array.resize(max_node_id + 2);
+
+    util::Log() << "Building node array";
+    util::StaticGraph<EdgeData>::EdgeIterator edge = 0;
+    util::StaticGraph<EdgeData>::EdgeIterator position = 0;
+    util::StaticGraph<EdgeData>::EdgeIterator last_edge;
+
+    // initializing 'first_edge'-field of nodes:
+    for (const auto node : util::irange(0u, max_used_node_id + 1))
+    {
+        last_edge = edge;
+        while ((edge < contracted_edge_count) && (contracted_edge_list[edge].source == node))
+        {
+            ++edge;
+        }
+        node_array[node].first_edge = position; //=edge
+        position += edge - last_edge;           // remove
+    }
+
+    for (const auto sentinel_counter :
+         util::irange<unsigned>(max_used_node_id + 1, node_array.size()))
+    {
+        // sentinel element, guarded against underflow
+        node_array[sentinel_counter].first_edge = contracted_edge_count;
+    }
+
+    util::Log() << "Serializing node array";
 
     RangebasedCRC32 crc32_calculator;
-    const unsigned checksum = crc32_calculator(contracted_edge_list);
+    const unsigned edges_crc32 = crc32_calculator(contracted_edge_list);
+    util::Log() << "Writing CRC32: " << edges_crc32;
 
-    QueryGraph query_graph{max_node_id + 1, contracted_edge_list};
+    const std::uint64_t node_array_size = node_array.size();
+    // serialize crc32, aka checksum
+    hsgr_output_file.WriteOne(edges_crc32);
+    // serialize number of nodes
+    hsgr_output_file.WriteOne(node_array_size);
+    // serialize number of edges
+    hsgr_output_file.WriteOne(contracted_edge_count);
+    // serialize all nodes
+    if (node_array_size > 0)
+    {
+        hsgr_output_file.WriteFrom(node_array.data(), node_array_size);
+    }
 
-    files::writeGraph(config.graph_output_path, checksum, query_graph);
+    // serialize all edges
+    util::Log() << "Building edge array";
+    std::size_t number_of_used_edges = 0;
+
+    util::StaticGraph<EdgeData>::EdgeArrayEntry current_edge;
+    for (const auto edge : util::irange<std::size_t>(0UL, contracted_edge_list.size()))
+    {
+        // some self-loops are required for oneway handling. Need to assertthat we only keep these
+        // (TODO)
+        // no eigen loops
+        // BOOST_ASSERT(contracted_edge_list[edge].source != contracted_edge_list[edge].target ||
+        // node_represents_oneway[contracted_edge_list[edge].source]);
+        current_edge.target = contracted_edge_list[edge].target;
+        current_edge.data = contracted_edge_list[edge].data;
+
+        // every target needs to be valid
+        BOOST_ASSERT(current_edge.target <= max_used_node_id);
+#ifndef NDEBUG
+        if (current_edge.data.weight <= 0)
+        {
+            util::Log(logWARNING) << "Edge: " << edge
+                                  << ",source: " << contracted_edge_list[edge].source
+                                  << ", target: " << contracted_edge_list[edge].target
+                                  << ", weight: " << current_edge.data.weight;
+
+            util::Log(logWARNING) << "Failed at adjacency list of node "
+                                  << contracted_edge_list[edge].source << "/"
+                                  << node_array.size() - 1;
+            throw util::exception("Edge weight is <= 0" + SOURCE_REF);
+        }
+#endif
+        hsgr_output_file.WriteOne(current_edge);
+
+        ++number_of_used_edges;
+    }
+
+    return number_of_used_edges;
 }
 
 } // namespace contractor

src/customize/customizer.cpp

@@ -1,14 +1,13 @@
 #include "customizer/customizer.hpp"
 #include "customizer/cell_customizer.hpp"
 #include "customizer/edge_based_graph.hpp"
+#include "customizer/io.hpp"
 
 #include "partition/cell_storage.hpp"
 #include "partition/edge_based_graph_reader.hpp"
-#include "partition/files.hpp"
+#include "partition/io.hpp"
 #include "partition/multi_level_partition.hpp"
 
-#include "storage/shared_memory_ownership.hpp"
-
 #include "updater/updater.hpp"
 
 #include "util/log.hpp"
@@ -84,7 +83,8 @@ auto LoadAndUpdateEdgeExpandedGraph(const CustomizationConfig &config,
     auto tidied =
         partition::prepareEdgesForUsageInGraph<StaticEdgeBasedGraphEdge>(std::move(directed));
     auto edge_based_graph =
-        std::make_unique<customizer::MultiLevelEdgeBasedGraph>(mlp, num_nodes, std::move(tidied));
+        std::make_unique<partition::MultiLevelGraph<EdgeBasedGraphEdgeData, false>>(
+            mlp, num_nodes, std::move(tidied));
 
     util::Log() << "Loaded edge based graph for mapping partition ids: "
                 << edge_based_graph->GetNumberOfEdges() << " edges, "
@@ -98,12 +98,12 @@ int Customizer::Run(const CustomizationConfig &config)
     TIMER_START(loading_data);
 
     partition::MultiLevelPartition mlp;
-    partition::files::readPartition(config.mld_partition_path, mlp);
+    partition::io::read(config.mld_partition_path, mlp);
 
     auto edge_based_graph = LoadAndUpdateEdgeExpandedGraph(config, mlp);
 
     partition::CellStorage storage;
-    partition::files::readCells(config.mld_storage_path, storage);
+    partition::io::read(config.mld_storage_path, storage);
     TIMER_STOP(loading_data);
     util::Log() << "Loading partition data took " << TIMER_SEC(loading_data) << " seconds";
 
@@ -114,12 +114,12 @@ int Customizer::Run(const CustomizationConfig &config)
     util::Log() << "Cells customization took " << TIMER_SEC(cell_customize) << " seconds";
 
     TIMER_START(writing_mld_data);
-    partition::files::writeCells(config.mld_storage_path, storage);
+    partition::io::write(config.mld_storage_path, storage);
     TIMER_STOP(writing_mld_data);
     util::Log() << "MLD customization writing took " << TIMER_SEC(writing_mld_data) << " seconds";
 
     TIMER_START(writing_graph);
-    partition::files::writeGraph(config.mld_graph_path, *edge_based_graph);
+    partition::io::write(config.mld_graph_path, *edge_based_graph);
     TIMER_STOP(writing_graph);
     util::Log() << "Graph writing took " << TIMER_SEC(writing_graph) << " seconds";
 

src/engine/routing_algorithms/alternative_path.cpp

@@ -19,8 +19,6 @@ namespace engine
 {
 namespace routing_algorithms
 {
-namespace ch
-{
 
 namespace
 {
@@ -28,7 +26,7 @@ const double constexpr VIAPATH_ALPHA = 0.10;
 const double constexpr VIAPATH_EPSILON = 0.15; // alternative at most 15% longer
 const double constexpr VIAPATH_GAMMA = 0.75;   // alternative shares at most 75% with the shortest.
 
-using QueryHeap = SearchEngineData<Algorithm>::QueryHeap;
+using QueryHeap = SearchEngineData::QueryHeap;
 using SearchSpaceEdge = std::pair<NodeID, NodeID>;
 
 struct RankedCandidateNode
@@ -50,14 +48,15 @@ struct RankedCandidateNode
 
 // todo: reorder parameters
 template <bool DIRECTION>
-void alternativeRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                            QueryHeap &heap1,
-                            QueryHeap &heap2,
-                            NodeID *middle_node,
-                            EdgeWeight *upper_bound_to_shortest_path_weight,
-                            std::vector<NodeID> &search_space_intersection,
-                            std::vector<SearchSpaceEdge> &search_space,
-                            const EdgeWeight min_edge_offset)
+void alternativeRoutingStep(
+    const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+    QueryHeap &heap1,
+    QueryHeap &heap2,
+    NodeID *middle_node,
+    EdgeWeight *upper_bound_to_shortest_path_weight,
+    std::vector<NodeID> &search_space_intersection,
+    std::vector<SearchSpaceEdge> &search_space,
+    const EdgeWeight min_edge_offset)
 {
     QueryHeap &forward_heap = DIRECTION == FORWARD_DIRECTION ? heap1 : heap2;
     QueryHeap &reverse_heap = DIRECTION == FORWARD_DIRECTION ? heap2 : heap1;
@@ -154,8 +153,8 @@ void retrievePackedAlternatePath(const QueryHeap &forward_heap1,
 // from v and intersecting against queues. only half-searches have to be
 // done at this stage
 void computeLengthAndSharingOfViaPath(
-    SearchEngineData<Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+    SearchEngineData &engine_working_data,
+    const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
     const NodeID via_node,
     int *real_length_of_via_path,
     int *sharing_of_via_path,
@@ -164,10 +163,10 @@ void computeLengthAndSharingOfViaPath(
 {
     engine_working_data.InitializeOrClearSecondThreadLocalStorage(facade.GetNumberOfNodes());
 
-    auto &existing_forward_heap = *engine_working_data.forward_heap_1;
-    auto &existing_reverse_heap = *engine_working_data.reverse_heap_1;
-    auto &new_forward_heap = *engine_working_data.forward_heap_2;
-    auto &new_reverse_heap = *engine_working_data.reverse_heap_2;
+    QueryHeap &existing_forward_heap = *engine_working_data.forward_heap_1;
+    QueryHeap &existing_reverse_heap = *engine_working_data.reverse_heap_1;
+    QueryHeap &new_forward_heap = *engine_working_data.forward_heap_2;
+    QueryHeap &new_reverse_heap = *engine_working_data.reverse_heap_2;
 
     std::vector<NodeID> packed_s_v_path;
     std::vector<NodeID> packed_v_t_path;
@@ -319,8 +318,8 @@ void computeLengthAndSharingOfViaPath(
 
 // conduct T-Test
 bool viaNodeCandidatePassesTTest(
-    SearchEngineData<Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+    SearchEngineData &engine_working_data,
+    const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
     QueryHeap &existing_forward_heap,
     QueryHeap &existing_reverse_heap,
     QueryHeap &new_forward_heap,
@@ -563,8 +562,8 @@ bool viaNodeCandidatePassesTTest(
 }
 
 InternalRouteResult
-alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                      const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+alternativePathSearch(SearchEngineData &engine_working_data,
+                      const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                       const PhantomNodes &phantom_node_pair)
 {
     InternalRouteResult raw_route_data;
@@ -579,10 +578,10 @@ alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
     engine_working_data.InitializeOrClearSecondThreadLocalStorage(facade.GetNumberOfNodes());
     engine_working_data.InitializeOrClearThirdThreadLocalStorage(facade.GetNumberOfNodes());
 
-    auto &forward_heap1 = *engine_working_data.forward_heap_1;
-    auto &reverse_heap1 = *engine_working_data.reverse_heap_1;
-    auto &forward_heap2 = *engine_working_data.forward_heap_2;
-    auto &reverse_heap2 = *engine_working_data.reverse_heap_2;
+    QueryHeap &forward_heap1 = *(engine_working_data.forward_heap_1);
+    QueryHeap &reverse_heap1 = *(engine_working_data.reverse_heap_1);
+    QueryHeap &forward_heap2 = *(engine_working_data.forward_heap_2);
+    QueryHeap &reverse_heap2 = *(engine_working_data.reverse_heap_2);
 
     EdgeWeight upper_bound_to_shortest_path_weight = INVALID_EDGE_WEIGHT;
     NodeID middle_node = SPECIAL_NODEID;
@@ -847,7 +846,6 @@ alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
     return raw_route_data;
 }
 
-} // namespace ch
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm}

src/engine/routing_algorithms/direct_shortest_path.cpp

@@ -47,7 +47,7 @@ extractRoute(const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &f
     return raw_route_data;
 }
 
-namespace detail
+namespace ch
 {
 /// This is a striped down version of the general shortest path algorithm.
 /// The general algorithm always computes two queries for each leg. This is only
@@ -55,18 +55,18 @@ namespace detail
 /// by the previous route.
 /// This variation is only an optimazation for graphs with slow queries, for example
 /// not fully contracted graphs.
-template <typename Algorithm>
+template <typename AlgorithmT>
 InternalRouteResult directShortestPathSearchImpl(
-    SearchEngineData<Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+    SearchEngineData &engine_working_data,
+    const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &facade,
     const PhantomNodes &phantom_nodes)
 {
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
     engine_working_data.InitializeOrClearSecondThreadLocalStorage(facade.GetNumberOfNodes());
-    auto &forward_heap = *engine_working_data.forward_heap_1;
-    auto &reverse_heap = *engine_working_data.reverse_heap_1;
-    auto &forward_core_heap = *engine_working_data.forward_heap_2;
-    auto &reverse_core_heap = *engine_working_data.reverse_heap_2;
+    auto &forward_heap = *(engine_working_data.forward_heap_1);
+    auto &reverse_heap = *(engine_working_data.reverse_heap_1);
+    auto &forward_core_heap = *(engine_working_data.forward_heap_2);
+    auto &reverse_core_heap = *(engine_working_data.reverse_heap_2);
     forward_heap.Clear();
     reverse_heap.Clear();
     forward_core_heap.Clear();
@@ -84,8 +84,7 @@ InternalRouteResult directShortestPathSearchImpl(
            weight,
            packed_leg,
            DO_NOT_FORCE_LOOPS,
-           DO_NOT_FORCE_LOOPS,
-           phantom_nodes);
+           DO_NOT_FORCE_LOOPS);
 
     std::vector<EdgeID> unpacked_edges;
     auto source_node = SPECIAL_NODEID, target_node = SPECIAL_NODEID;
@@ -94,7 +93,7 @@ InternalRouteResult directShortestPathSearchImpl(
         source_node = packed_leg.front();
         target_node = packed_leg.back();
         unpacked_edges.reserve(packed_leg.size());
-        ch::unpackPath(
+        unpackPath(
             facade,
             packed_leg.begin(),
             packed_leg.end(),
@@ -109,30 +108,34 @@ InternalRouteResult directShortestPathSearchImpl(
 
 template <>
 InternalRouteResult directShortestPathSearch(
-    SearchEngineData<corech::Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+    SearchEngineData &engine_working_data,
+    const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
     const PhantomNodes &phantom_nodes)
 {
-    return detail::directShortestPathSearchImpl(engine_working_data, facade, phantom_nodes);
+    return ch::directShortestPathSearchImpl(engine_working_data, facade, phantom_nodes);
 }
 
 template <>
 InternalRouteResult directShortestPathSearch(
-    SearchEngineData<ch::Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+    SearchEngineData &engine_working_data,
+    const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
     const PhantomNodes &phantom_nodes)
 {
-    return detail::directShortestPathSearchImpl(engine_working_data, facade, phantom_nodes);
+    return ch::directShortestPathSearchImpl(engine_working_data, facade, phantom_nodes);
 }
 
+template <>
 InternalRouteResult directShortestPathSearch(
-    SearchEngineData<mld::Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
+    SearchEngineData &engine_working_data,
+    const datafacade::ContiguousInternalMemoryDataFacade<algorithm::MLD> &facade,
     const PhantomNodes &phantom_nodes)
 {
-    engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
-    auto &forward_heap = *engine_working_data.forward_heap_1;
-    auto &reverse_heap = *engine_working_data.reverse_heap_1;
+    engine_working_data.InitializeOrClearMultiLayerDijkstraThreadLocalStorage(
+        facade.GetNumberOfNodes());
+    auto &forward_heap = *(engine_working_data.mld_forward_heap);
+    auto &reverse_heap = *(engine_working_data.mld_reverse_heap);
+    forward_heap.Clear();
+    reverse_heap.Clear();
     insertNodesInHeaps(forward_heap, reverse_heap, phantom_nodes);
 
     // TODO: when structured bindings will be allowed change to
@@ -140,8 +143,8 @@ InternalRouteResult directShortestPathSearch(
     EdgeWeight weight;
     NodeID source_node, target_node;
     std::vector<EdgeID> unpacked_edges;
-    std::tie(weight, source_node, target_node, unpacked_edges) = mld::search(
-        facade, forward_heap, reverse_heap, DO_NOT_FORCE_LOOPS, DO_NOT_FORCE_LOOPS, phantom_nodes);
+    std::tie(weight, source_node, target_node, unpacked_edges) =
+        mld::search(facade, forward_heap, reverse_heap, phantom_nodes);
 
     return extractRoute(facade, weight, source_node, target_node, unpacked_edges, phantom_nodes);
 }

src/engine/routing_algorithms/many_to_many.cpp

@@ -15,10 +15,7 @@ namespace engine
 namespace routing_algorithms
 {
 
-namespace ch
-{
-
-using ManyToManyQueryHeap = SearchEngineData<Algorithm>::ManyToManyQueryHeap;
+using ManyToManyQueryHeap = SearchEngineData::ManyToManyQueryHeap;
 
 namespace
 {
@@ -37,7 +34,7 @@ struct NodeBucket
 using SearchSpaceWithBuckets = std::unordered_map<NodeID, std::vector<NodeBucket>>;
 
 template <bool DIRECTION>
-void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         const EdgeWeight duration,
@@ -72,7 +69,7 @@ void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<Alg
     }
 }
 
-void forwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void forwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                         const unsigned row_idx,
                         const unsigned number_of_targets,
                         ManyToManyQueryHeap &query_heap,
@@ -129,10 +126,11 @@ void forwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Alg
     relaxOutgoingEdges<FORWARD_DIRECTION>(facade, node, source_weight, source_duration, query_heap);
 }
 
-void backwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                         const unsigned column_idx,
-                         ManyToManyQueryHeap &query_heap,
-                         SearchSpaceWithBuckets &search_space_with_buckets)
+void backwardRoutingStep(
+    const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+    const unsigned column_idx,
+    ManyToManyQueryHeap &query_heap,
+    SearchSpaceWithBuckets &search_space_with_buckets)
 {
     const NodeID node = query_heap.DeleteMin();
     const EdgeWeight target_weight = query_heap.GetKey(node);
@@ -151,8 +149,8 @@ void backwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Al
 }
 
 std::vector<EdgeWeight>
-manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
-                 const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+manyToManySearch(SearchEngineData &engine_working_data,
+                 const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                  const std::vector<PhantomNode> &phantom_nodes,
                  const std::vector<std::size_t> &source_indices,
                  const std::vector<std::size_t> &target_indices)
@@ -242,7 +240,6 @@ manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
     return durations_table;
 }
 
-} // namespace ch
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm

src/engine/routing_algorithms/map_matching.cpp

@@ -1,6 +1,5 @@
 #include "engine/routing_algorithms/map_matching.hpp"
 #include "engine/routing_algorithms/routing_base_ch.hpp"
-#include "engine/routing_algorithms/routing_base_mld.hpp"
 
 #include "engine/map_matching/hidden_markov_model.hpp"
 #include "engine/map_matching/matching_confidence.hpp"
@@ -48,14 +47,15 @@ unsigned getMedianSampleTime(const std::vector<unsigned> &timestamps)
 }
 }
 
-template <typename Algorithm>
-SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
-                            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                            const CandidateLists &candidates_list,
-                            const std::vector<util::Coordinate> &trace_coordinates,
-                            const std::vector<unsigned> &trace_timestamps,
-                            const std::vector<boost::optional<double>> &trace_gps_precision,
-                            const bool allow_splitting)
+template <typename AlgorithmT>
+SubMatchingList
+mapMatchingImpl(SearchEngineData &engine_working_data,
+                const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &facade,
+                const CandidateLists &candidates_list,
+                const std::vector<util::Coordinate> &trace_coordinates,
+                const std::vector<unsigned> &trace_timestamps,
+                const std::vector<boost::optional<double>> &trace_gps_precision,
+                const bool allow_splitting)
 {
     map_matching::MatchingConfidence confidence;
     map_matching::EmissionLogProbability default_emission_log_probability(DEFAULT_GPS_PRECISION);
@@ -141,14 +141,13 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
         return sub_matchings;
     }
 
-    const auto nodes_number = facade.GetNumberOfNodes();
-    engine_working_data.InitializeOrClearFirstThreadLocalStorage(nodes_number);
-    engine_working_data.InitializeOrClearSecondThreadLocalStorage(nodes_number);
+    engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
+    engine_working_data.InitializeOrClearSecondThreadLocalStorage(facade.GetNumberOfNodes());
 
-    auto &forward_heap = *engine_working_data.forward_heap_1;
-    auto &reverse_heap = *engine_working_data.reverse_heap_1;
-    auto &forward_core_heap = *engine_working_data.forward_heap_2;
-    auto &reverse_core_heap = *engine_working_data.reverse_heap_2;
+    auto &forward_heap = *(engine_working_data.forward_heap_1);
+    auto &reverse_heap = *(engine_working_data.reverse_heap_1);
+    auto &forward_core_heap = *(engine_working_data.forward_heap_2);
+    auto &reverse_core_heap = *(engine_working_data.reverse_heap_2);
 
     std::size_t breakage_begin = map_matching::INVALID_STATE;
     std::vector<std::size_t> split_points;
@@ -220,14 +219,14 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                     }
 
                     double network_distance =
-                        getNetworkDistance(facade,
-                                           forward_heap,
-                                           reverse_heap,
-                                           forward_core_heap,
-                                           reverse_core_heap,
-                                           prev_unbroken_timestamps_list[s].phantom_node,
-                                           current_timestamps_list[s_prime].phantom_node,
-                                           duration_upper_bound);
+                        ch::getNetworkDistance(facade,
+                                               forward_heap,
+                                               reverse_heap,
+                                               forward_core_heap,
+                                               reverse_core_heap,
+                                               prev_unbroken_timestamps_list[s].phantom_node,
+                                               current_timestamps_list[s_prime].phantom_node,
+                                               duration_upper_bound);
 
                     // get distance diff between loc1/2 and locs/s_prime
                     const auto d_t = std::abs(network_distance - haversine_distance);
@@ -420,32 +419,42 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
     return sub_matchings;
 }
 
-template SubMatchingList
-mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+SubMatchingList
+mapMatching(SearchEngineData &engine_working_data,
+            const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
             const CandidateLists &candidates_list,
             const std::vector<util::Coordinate> &trace_coordinates,
             const std::vector<unsigned> &trace_timestamps,
             const std::vector<boost::optional<double>> &trace_gps_precision,
-            const bool allow_splitting);
+            const bool use_tidying)
+{
+    return mapMatchingImpl(engine_working_data,
+                           facade,
+                           candidates_list,
+                           trace_coordinates,
+                           trace_timestamps,
+                           trace_gps_precision,
+                           use_tidying);
+}
 
-template SubMatchingList
-mapMatching(SearchEngineData<corech::Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+SubMatchingList
+mapMatching(SearchEngineData &engine_working_data,
+            const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
             const CandidateLists &candidates_list,
             const std::vector<util::Coordinate> &trace_coordinates,
             const std::vector<unsigned> &trace_timestamps,
             const std::vector<boost::optional<double>> &trace_gps_precision,
-            const bool allow_splitting);
+            const bool use_tidying)
+{
 
-template SubMatchingList
-mapMatching(SearchEngineData<mld::Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-            const CandidateLists &candidates_list,
-            const std::vector<util::Coordinate> &trace_coordinates,
-            const std::vector<unsigned> &trace_timestamps,
-            const std::vector<boost::optional<double>> &trace_gps_precision,
-            const bool allow_splitting);
+    return mapMatchingImpl(engine_working_data,
+                           facade,
+                           candidates_list,
+                           trace_coordinates,
+                           trace_timestamps,
+                           trace_gps_precision,
+                           use_tidying);
+}
 
 } // namespace routing_algorithms
 } // namespace engine

src/engine/routing_algorithms/routing_base.cpp

@@ -1,28 +0,0 @@
-#include "engine/routing_algorithms/routing_base.hpp"
-
-namespace osrm
-{
-namespace engine
-{
-namespace routing_algorithms
-{
-
-bool needsLoopForward(const PhantomNode &source_phantom, const PhantomNode &target_phantom)
-{
-    return source_phantom.forward_segment_id.enabled && target_phantom.forward_segment_id.enabled &&
-           source_phantom.forward_segment_id.id == target_phantom.forward_segment_id.id &&
-           source_phantom.GetForwardWeightPlusOffset() >
-               target_phantom.GetForwardWeightPlusOffset();
-}
-
-bool needsLoopBackwards(const PhantomNode &source_phantom, const PhantomNode &target_phantom)
-{
-    return source_phantom.reverse_segment_id.enabled && target_phantom.reverse_segment_id.enabled &&
-           source_phantom.reverse_segment_id.id == target_phantom.reverse_segment_id.id &&
-           source_phantom.GetReverseWeightPlusOffset() >
-               target_phantom.GetReverseWeightPlusOffset();
-}
-
-} // namespace routing_algorithms
-} // namespace engine
-} // namespace osrm

src/engine/routing_algorithms/routing_base_ch.cpp

@@ -16,7 +16,7 @@ namespace ch
  * @param to the node the CH edge finishes at
  * @param unpacked_path the sequence of original NodeIDs that make up the expanded CH edge
  */
-void unpackEdge(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void unpackEdge(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                 const NodeID from,
                 const NodeID to,
                 std::vector<NodeID> &unpacked_path)
@@ -31,8 +31,8 @@ void unpackEdge(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
     unpacked_path.emplace_back(to);
 }
 
-void retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                                const SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+void retrievePackedPathFromHeap(const SearchEngineData::QueryHeap &forward_heap,
+                                const SearchEngineData::QueryHeap &reverse_heap,
                                 const NodeID middle_node_id,
                                 std::vector<NodeID> &packed_path)
 {
@@ -42,7 +42,7 @@ void retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &fo
     retrievePackedPathFromSingleHeap(reverse_heap, middle_node_id, packed_path);
 }
 
-void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHeap &search_heap,
+void retrievePackedPathFromSingleHeap(const SearchEngineData::QueryHeap &search_heap,
                                       const NodeID middle_node_id,
                                       std::vector<NodeID> &packed_path)
 {
@@ -71,9 +71,9 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHe
 // && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
-void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-            SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-            SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+void search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+            SearchEngineData::QueryHeap &forward_heap,
+            SearchEngineData::QueryHeap &reverse_heap,
             EdgeWeight &weight,
             std::vector<NodeID> &packed_leg,
             const bool force_loop_forward,
@@ -139,15 +139,313 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &fac
     }
 }
 
+// assumes that heaps are already setup correctly.
+// A forced loop might be necessary, if source and target are on the same segment.
+// If this is the case and the offsets of the respective direction are larger for the source
+// than the target
+// then a force loop is required (e.g. source_phantom.forward_segment_id ==
+// target_phantom.forward_segment_id
+// && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
+// requires
+// a force loop, if the heaps have been initialized with positive offsets.
+void search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
+            SearchEngineData::QueryHeap &forward_heap,
+            SearchEngineData::QueryHeap &reverse_heap,
+            SearchEngineData::QueryHeap &forward_core_heap,
+            SearchEngineData::QueryHeap &reverse_core_heap,
+            EdgeWeight &weight,
+            std::vector<NodeID> &packed_leg,
+            const bool force_loop_forward,
+            const bool force_loop_reverse,
+            EdgeWeight weight_upper_bound)
+{
+    NodeID middle = SPECIAL_NODEID;
+    weight = weight_upper_bound;
+
+    using CoreEntryPoint = std::tuple<NodeID, EdgeWeight, NodeID>;
+    std::vector<CoreEntryPoint> forward_entry_points;
+    std::vector<CoreEntryPoint> reverse_entry_points;
+
+    // get offset to account for offsets on phantom nodes on compressed edges
+    const auto min_edge_offset = std::min(0, forward_heap.MinKey());
+    // we only every insert negative offsets for nodes in the forward heap
+    BOOST_ASSERT(reverse_heap.MinKey() >= 0);
+
+    // run two-Target Dijkstra routing step.
+    while (0 < (forward_heap.Size() + reverse_heap.Size()))
+    {
+        if (!forward_heap.Empty())
+        {
+            if (facade.IsCoreNode(forward_heap.Min()))
+            {
+                const NodeID node = forward_heap.DeleteMin();
+                const EdgeWeight key = forward_heap.GetKey(node);
+                forward_entry_points.emplace_back(node, key, forward_heap.GetData(node).parent);
+            }
+            else
+            {
+                routingStep<FORWARD_DIRECTION>(facade,
+                                               forward_heap,
+                                               reverse_heap,
+                                               middle,
+                                               weight,
+                                               min_edge_offset,
+                                               force_loop_forward,
+                                               force_loop_reverse);
+            }
+        }
+        if (!reverse_heap.Empty())
+        {
+            if (facade.IsCoreNode(reverse_heap.Min()))
+            {
+                const NodeID node = reverse_heap.DeleteMin();
+                const EdgeWeight key = reverse_heap.GetKey(node);
+                reverse_entry_points.emplace_back(node, key, reverse_heap.GetData(node).parent);
+            }
+            else
+            {
+                routingStep<REVERSE_DIRECTION>(facade,
+                                               reverse_heap,
+                                               forward_heap,
+                                               middle,
+                                               weight,
+                                               min_edge_offset,
+                                               force_loop_reverse,
+                                               force_loop_forward);
+            }
+        }
+    }
+
+    const auto insertInCoreHeap = [](const CoreEntryPoint &p,
+                                     SearchEngineData::QueryHeap &core_heap) {
+        NodeID id;
+        EdgeWeight weight;
+        NodeID parent;
+        // TODO this should use std::apply when we get c++17 support
+        std::tie(id, weight, parent) = p;
+        core_heap.Insert(id, weight, parent);
+    };
+
+    forward_core_heap.Clear();
+    for (const auto &p : forward_entry_points)
+    {
+        insertInCoreHeap(p, forward_core_heap);
+    }
+
+    reverse_core_heap.Clear();
+    for (const auto &p : reverse_entry_points)
+    {
+        insertInCoreHeap(p, reverse_core_heap);
+    }
+
+    // get offset to account for offsets on phantom nodes on compressed edges
+    EdgeWeight min_core_edge_offset = 0;
+    if (forward_core_heap.Size() > 0)
+    {
+        min_core_edge_offset = std::min(min_core_edge_offset, forward_core_heap.MinKey());
+    }
+    if (reverse_core_heap.Size() > 0 && reverse_core_heap.MinKey() < 0)
+    {
+        min_core_edge_offset = std::min(min_core_edge_offset, reverse_core_heap.MinKey());
+    }
+    BOOST_ASSERT(min_core_edge_offset <= 0);
+
+    // run two-target Dijkstra routing step on core with termination criterion
+    while (0 < forward_core_heap.Size() && 0 < reverse_core_heap.Size() &&
+           weight > (forward_core_heap.MinKey() + reverse_core_heap.MinKey()))
+    {
+        routingStep<FORWARD_DIRECTION, DISABLE_STALLING>(facade,
+                                                         forward_core_heap,
+                                                         reverse_core_heap,
+                                                         middle,
+                                                         weight,
+                                                         min_core_edge_offset,
+                                                         force_loop_forward,
+                                                         force_loop_reverse);
+
+        routingStep<REVERSE_DIRECTION, DISABLE_STALLING>(facade,
+                                                         reverse_core_heap,
+                                                         forward_core_heap,
+                                                         middle,
+                                                         weight,
+                                                         min_core_edge_offset,
+                                                         force_loop_reverse,
+                                                         force_loop_forward);
+    }
+
+    // No path found for both target nodes?
+    if (weight_upper_bound <= weight || SPECIAL_NODEID == middle)
+    {
+        weight = INVALID_EDGE_WEIGHT;
+        return;
+    }
+
+    // Was a paths over one of the forward/reverse nodes not found?
+    BOOST_ASSERT_MSG((SPECIAL_NODEID != middle && INVALID_EDGE_WEIGHT != weight), "no path found");
+
+    // we need to unpack sub path from core heaps
+    if (facade.IsCoreNode(middle))
+    {
+        if (weight != forward_core_heap.GetKey(middle) + reverse_core_heap.GetKey(middle))
+        {
+            // self loop
+            BOOST_ASSERT(forward_core_heap.GetData(middle).parent == middle &&
+                         reverse_core_heap.GetData(middle).parent == middle);
+            packed_leg.push_back(middle);
+            packed_leg.push_back(middle);
+        }
+        else
+        {
+            std::vector<NodeID> packed_core_leg;
+            retrievePackedPathFromHeap(
+                forward_core_heap, reverse_core_heap, middle, packed_core_leg);
+            BOOST_ASSERT(packed_core_leg.size() > 0);
+            retrievePackedPathFromSingleHeap(forward_heap, packed_core_leg.front(), packed_leg);
+            std::reverse(packed_leg.begin(), packed_leg.end());
+            packed_leg.insert(packed_leg.end(), packed_core_leg.begin(), packed_core_leg.end());
+            retrievePackedPathFromSingleHeap(reverse_heap, packed_core_leg.back(), packed_leg);
+        }
+    }
+    else
+    {
+        if (weight != forward_heap.GetKey(middle) + reverse_heap.GetKey(middle))
+        {
+            // self loop
+            BOOST_ASSERT(forward_heap.GetData(middle).parent == middle &&
+                         reverse_heap.GetData(middle).parent == middle);
+            packed_leg.push_back(middle);
+            packed_leg.push_back(middle);
+        }
+        else
+        {
+            retrievePackedPathFromHeap(forward_heap, reverse_heap, middle, packed_leg);
+        }
+    }
+}
+
+bool needsLoopForward(const PhantomNode &source_phantom, const PhantomNode &target_phantom)
+{
+    return source_phantom.forward_segment_id.enabled && target_phantom.forward_segment_id.enabled &&
+           source_phantom.forward_segment_id.id == target_phantom.forward_segment_id.id &&
+           source_phantom.GetForwardWeightPlusOffset() >
+               target_phantom.GetForwardWeightPlusOffset();
+}
+
+bool needsLoopBackwards(const PhantomNode &source_phantom, const PhantomNode &target_phantom)
+{
+    return source_phantom.reverse_segment_id.enabled && target_phantom.reverse_segment_id.enabled &&
+           source_phantom.reverse_segment_id.id == target_phantom.reverse_segment_id.id &&
+           source_phantom.GetReverseWeightPlusOffset() >
+               target_phantom.GetReverseWeightPlusOffset();
+}
+
+double getPathDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                       const std::vector<NodeID> &packed_path,
+                       const PhantomNode &source_phantom,
+                       const PhantomNode &target_phantom)
+{
+    std::vector<PathData> unpacked_path;
+    PhantomNodes nodes;
+    nodes.source_phantom = source_phantom;
+    nodes.target_phantom = target_phantom;
+    unpackPath(facade, packed_path.begin(), packed_path.end(), nodes, unpacked_path);
+
+    using util::coordinate_calculation::detail::DEGREE_TO_RAD;
+    using util::coordinate_calculation::detail::EARTH_RADIUS;
+
+    double distance = 0;
+    double prev_lat = static_cast<double>(toFloating(source_phantom.location.lat)) * DEGREE_TO_RAD;
+    double prev_lon = static_cast<double>(toFloating(source_phantom.location.lon)) * DEGREE_TO_RAD;
+    double prev_cos = std::cos(prev_lat);
+    for (const auto &p : unpacked_path)
+    {
+        const auto current_coordinate = facade.GetCoordinateOfNode(p.turn_via_node);
+
+        const double current_lat =
+            static_cast<double>(toFloating(current_coordinate.lat)) * DEGREE_TO_RAD;
+        const double current_lon =
+            static_cast<double>(toFloating(current_coordinate.lon)) * DEGREE_TO_RAD;
+        const double current_cos = std::cos(current_lat);
+
+        const double sin_dlon = std::sin((prev_lon - current_lon) / 2.0);
+        const double sin_dlat = std::sin((prev_lat - current_lat) / 2.0);
+
+        const double aharv = sin_dlat * sin_dlat + prev_cos * current_cos * sin_dlon * sin_dlon;
+        const double charv = 2. * std::atan2(std::sqrt(aharv), std::sqrt(1.0 - aharv));
+        distance += EARTH_RADIUS * charv;
+
+        prev_lat = current_lat;
+        prev_lon = current_lon;
+        prev_cos = current_cos;
+    }
+
+    const double current_lat =
+        static_cast<double>(toFloating(target_phantom.location.lat)) * DEGREE_TO_RAD;
+    const double current_lon =
+        static_cast<double>(toFloating(target_phantom.location.lon)) * DEGREE_TO_RAD;
+    const double current_cos = std::cos(current_lat);
+
+    const double sin_dlon = std::sin((prev_lon - current_lon) / 2.0);
+    const double sin_dlat = std::sin((prev_lat - current_lat) / 2.0);
+
+    const double aharv = sin_dlat * sin_dlat + prev_cos * current_cos * sin_dlon * sin_dlon;
+    const double charv = 2. * std::atan2(std::sqrt(aharv), std::sqrt(1.0 - aharv));
+    distance += EARTH_RADIUS * charv;
+
+    return distance;
+}
+
 // Requires the heaps for be empty
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
-double getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                          SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                          SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                          const PhantomNode &source_phantom,
-                          const PhantomNode &target_phantom,
-                          EdgeWeight weight_upper_bound)
+double
+getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
+                   SearchEngineData::QueryHeap &forward_heap,
+                   SearchEngineData::QueryHeap &reverse_heap,
+                   SearchEngineData::QueryHeap &forward_core_heap,
+                   SearchEngineData::QueryHeap &reverse_core_heap,
+                   const PhantomNode &source_phantom,
+                   const PhantomNode &target_phantom,
+                   EdgeWeight weight_upper_bound)
+{
+    forward_heap.Clear();
+    reverse_heap.Clear();
+    forward_core_heap.Clear();
+    reverse_core_heap.Clear();
+
+    insertNodesInHeaps(forward_heap, reverse_heap, {source_phantom, target_phantom});
+
+    EdgeWeight weight = INVALID_EDGE_WEIGHT;
+    std::vector<NodeID> packed_path;
+    search(facade,
+           forward_heap,
+           reverse_heap,
+           forward_core_heap,
+           reverse_core_heap,
+           weight,
+           packed_path,
+           DO_NOT_FORCE_LOOPS,
+           DO_NOT_FORCE_LOOPS,
+           weight_upper_bound);
+
+    double distance = std::numeric_limits<double>::max();
+    if (weight != INVALID_EDGE_WEIGHT)
+    {
+        return getPathDistance(facade, packed_path, source_phantom, target_phantom);
+    }
+    return distance;
+}
+
+// Requires the heaps for be empty
+// If heaps should be adjusted to be initialized outside of this function,
+// the addition of force_loop parameters might be required
+double
+getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                   SearchEngineData::QueryHeap &forward_heap,
+                   SearchEngineData::QueryHeap &reverse_heap,
+                   const PhantomNode &source_phantom,
+                   const PhantomNode &target_phantom,
+                   EdgeWeight weight_upper_bound)
 {
     forward_heap.Clear();
     reverse_heap.Clear();
@@ -194,251 +492,10 @@ double getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<A
         return std::numeric_limits<double>::max();
     }
 
-    std::vector<PathData> unpacked_path;
-    unpackPath(facade,
-               packed_path.begin(),
-               packed_path.end(),
-               {source_phantom, target_phantom},
-               unpacked_path);
-
-    return getPathDistance(facade, unpacked_path, source_phantom, target_phantom);
+    return getPathDistance(facade, packed_path, source_phantom, target_phantom);
 }
+
 } // namespace ch
-
-namespace corech
-{
-// Assumes that heaps are already setup correctly.
-// A forced loop might be necessary, if source and target are on the same segment.
-// If this is the case and the offsets of the respective direction are larger for the source
-// than the target
-// then a force loop is required (e.g. source_phantom.forward_segment_id ==
-// target_phantom.forward_segment_id
-// && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
-// requires
-// a force loop, if the heaps have been initialized with positive offsets.
-void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-            SearchEngineData<ch::Algorithm>::QueryHeap &forward_heap,
-            SearchEngineData<ch::Algorithm>::QueryHeap &reverse_heap,
-            SearchEngineData<ch::Algorithm>::QueryHeap &forward_core_heap,
-            SearchEngineData<ch::Algorithm>::QueryHeap &reverse_core_heap,
-            EdgeWeight &weight,
-            std::vector<NodeID> &packed_leg,
-            const bool force_loop_forward,
-            const bool force_loop_reverse,
-            const PhantomNodes & /*phantom_nodes*/,
-            EdgeWeight weight_upper_bound)
-{
-    NodeID middle = SPECIAL_NODEID;
-    weight = weight_upper_bound;
-
-    using CoreEntryPoint = std::tuple<NodeID, EdgeWeight, NodeID>;
-    std::vector<CoreEntryPoint> forward_entry_points;
-    std::vector<CoreEntryPoint> reverse_entry_points;
-
-    // get offset to account for offsets on phantom nodes on compressed edges
-    const auto min_edge_offset = std::min(0, forward_heap.MinKey());
-    // we only every insert negative offsets for nodes in the forward heap
-    BOOST_ASSERT(reverse_heap.MinKey() >= 0);
-
-    // run two-Target Dijkstra routing step.
-    while (0 < (forward_heap.Size() + reverse_heap.Size()))
-    {
-        if (!forward_heap.Empty())
-        {
-            if (facade.IsCoreNode(forward_heap.Min()))
-            {
-                const NodeID node = forward_heap.DeleteMin();
-                const EdgeWeight key = forward_heap.GetKey(node);
-                forward_entry_points.emplace_back(node, key, forward_heap.GetData(node).parent);
-            }
-            else
-            {
-                ch::routingStep<FORWARD_DIRECTION>(facade,
-                                                   forward_heap,
-                                                   reverse_heap,
-                                                   middle,
-                                                   weight,
-                                                   min_edge_offset,
-                                                   force_loop_forward,
-                                                   force_loop_reverse);
-            }
-        }
-        if (!reverse_heap.Empty())
-        {
-            if (facade.IsCoreNode(reverse_heap.Min()))
-            {
-                const NodeID node = reverse_heap.DeleteMin();
-                const EdgeWeight key = reverse_heap.GetKey(node);
-                reverse_entry_points.emplace_back(node, key, reverse_heap.GetData(node).parent);
-            }
-            else
-            {
-                ch::routingStep<REVERSE_DIRECTION>(facade,
-                                                   reverse_heap,
-                                                   forward_heap,
-                                                   middle,
-                                                   weight,
-                                                   min_edge_offset,
-                                                   force_loop_reverse,
-                                                   force_loop_forward);
-            }
-        }
-    }
-
-    const auto insertInCoreHeap = [](const CoreEntryPoint &p,
-                                     SearchEngineData<ch::Algorithm>::QueryHeap &core_heap) {
-        NodeID id;
-        EdgeWeight weight;
-        NodeID parent;
-        // TODO this should use std::apply when we get c++17 support
-        std::tie(id, weight, parent) = p;
-        core_heap.Insert(id, weight, parent);
-    };
-
-    forward_core_heap.Clear();
-    for (const auto &p : forward_entry_points)
-    {
-        insertInCoreHeap(p, forward_core_heap);
-    }
-
-    reverse_core_heap.Clear();
-    for (const auto &p : reverse_entry_points)
-    {
-        insertInCoreHeap(p, reverse_core_heap);
-    }
-
-    // get offset to account for offsets on phantom nodes on compressed edges
-    EdgeWeight min_core_edge_offset = 0;
-    if (forward_core_heap.Size() > 0)
-    {
-        min_core_edge_offset = std::min(min_core_edge_offset, forward_core_heap.MinKey());
-    }
-    if (reverse_core_heap.Size() > 0 && reverse_core_heap.MinKey() < 0)
-    {
-        min_core_edge_offset = std::min(min_core_edge_offset, reverse_core_heap.MinKey());
-    }
-    BOOST_ASSERT(min_core_edge_offset <= 0);
-
-    // run two-target Dijkstra routing step on core with termination criterion
-    while (0 < forward_core_heap.Size() && 0 < reverse_core_heap.Size() &&
-           weight > (forward_core_heap.MinKey() + reverse_core_heap.MinKey()))
-    {
-        ch::routingStep<FORWARD_DIRECTION, ch::DISABLE_STALLING>(facade,
-                                                                 forward_core_heap,
-                                                                 reverse_core_heap,
-                                                                 middle,
-                                                                 weight,
-                                                                 min_core_edge_offset,
-                                                                 force_loop_forward,
-                                                                 force_loop_reverse);
-
-        ch::routingStep<REVERSE_DIRECTION, ch::DISABLE_STALLING>(facade,
-                                                                 reverse_core_heap,
-                                                                 forward_core_heap,
-                                                                 middle,
-                                                                 weight,
-                                                                 min_core_edge_offset,
-                                                                 force_loop_reverse,
-                                                                 force_loop_forward);
-    }
-
-    // No path found for both target nodes?
-    if (weight_upper_bound <= weight || SPECIAL_NODEID == middle)
-    {
-        weight = INVALID_EDGE_WEIGHT;
-        return;
-    }
-
-    // Was a paths over one of the forward/reverse nodes not found?
-    BOOST_ASSERT_MSG((SPECIAL_NODEID != middle && INVALID_EDGE_WEIGHT != weight), "no path found");
-
-    // we need to unpack sub path from core heaps
-    if (facade.IsCoreNode(middle))
-    {
-        if (weight != forward_core_heap.GetKey(middle) + reverse_core_heap.GetKey(middle))
-        {
-            // self loop
-            BOOST_ASSERT(forward_core_heap.GetData(middle).parent == middle &&
-                         reverse_core_heap.GetData(middle).parent == middle);
-            packed_leg.push_back(middle);
-            packed_leg.push_back(middle);
-        }
-        else
-        {
-            std::vector<NodeID> packed_core_leg;
-            ch::retrievePackedPathFromHeap(
-                forward_core_heap, reverse_core_heap, middle, packed_core_leg);
-            BOOST_ASSERT(packed_core_leg.size() > 0);
-            ch::retrievePackedPathFromSingleHeap(forward_heap, packed_core_leg.front(), packed_leg);
-            std::reverse(packed_leg.begin(), packed_leg.end());
-            packed_leg.insert(packed_leg.end(), packed_core_leg.begin(), packed_core_leg.end());
-            ch::retrievePackedPathFromSingleHeap(reverse_heap, packed_core_leg.back(), packed_leg);
-        }
-    }
-    else
-    {
-        if (weight != forward_heap.GetKey(middle) + reverse_heap.GetKey(middle))
-        {
-            // self loop
-            BOOST_ASSERT(forward_heap.GetData(middle).parent == middle &&
-                         reverse_heap.GetData(middle).parent == middle);
-            packed_leg.push_back(middle);
-            packed_leg.push_back(middle);
-        }
-        else
-        {
-            ch::retrievePackedPathFromHeap(forward_heap, reverse_heap, middle, packed_leg);
-        }
-    }
-}
-
-// Requires the heaps for be empty
-// If heaps should be adjusted to be initialized outside of this function,
-// the addition of force_loop parameters might be required
-double getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                          SearchEngineData<ch::Algorithm>::QueryHeap &forward_heap,
-                          SearchEngineData<ch::Algorithm>::QueryHeap &reverse_heap,
-                          SearchEngineData<ch::Algorithm>::QueryHeap &forward_core_heap,
-                          SearchEngineData<ch::Algorithm>::QueryHeap &reverse_core_heap,
-                          const PhantomNode &source_phantom,
-                          const PhantomNode &target_phantom,
-                          EdgeWeight weight_upper_bound)
-{
-    forward_heap.Clear();
-    reverse_heap.Clear();
-    forward_core_heap.Clear();
-    reverse_core_heap.Clear();
-
-    insertNodesInHeaps(forward_heap, reverse_heap, {source_phantom, target_phantom});
-
-    EdgeWeight weight = INVALID_EDGE_WEIGHT;
-    std::vector<NodeID> packed_path;
-    search(facade,
-           forward_heap,
-           reverse_heap,
-           forward_core_heap,
-           reverse_core_heap,
-           weight,
-           packed_path,
-           DO_NOT_FORCE_LOOPS,
-           DO_NOT_FORCE_LOOPS,
-           {source_phantom, target_phantom},
-           weight_upper_bound);
-
-    if (weight == INVALID_EDGE_WEIGHT)
-        return std::numeric_limits<double>::max();
-
-    std::vector<PathData> unpacked_path;
-    ch::unpackPath(facade,
-                   packed_path.begin(),
-                   packed_path.end(),
-                   {source_phantom, target_phantom},
-                   unpacked_path);
-
-    return getPathDistance(facade, unpacked_path, source_phantom, target_phantom);
-}
-} // namespace corech
-
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm

src/engine/routing_algorithms/shortest_path.cpp

@@ -1,6 +1,5 @@
 #include "engine/routing_algorithms/shortest_path.hpp"
 #include "engine/routing_algorithms/routing_base_ch.hpp"
-#include "engine/routing_algorithms/routing_base_mld.hpp"
 
 #include <boost/assert.hpp>
 #include <boost/optional.hpp>
@@ -17,15 +16,16 @@ namespace
 {
 
 const static constexpr bool DO_NOT_FORCE_LOOP = false;
+using QueryHeap = SearchEngineData::QueryHeap;
 
 // allows a uturn at the target_phantom
 // searches source forward/reverse -> target forward/reverse
-template <typename Algorithm>
-void searchWithUTurn(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                     typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                     typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                     typename SearchEngineData<Algorithm>::QueryHeap &forward_core_heap,
-                     typename SearchEngineData<Algorithm>::QueryHeap &reverse_core_heap,
+template <typename AlgorithmT>
+void searchWithUTurn(const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &facade,
+                     QueryHeap &forward_heap,
+                     QueryHeap &reverse_heap,
+                     QueryHeap &forward_core_heap,
+                     QueryHeap &reverse_core_heap,
                      const bool search_from_forward_node,
                      const bool search_from_reverse_node,
                      const bool search_to_forward_node,
@@ -71,24 +71,24 @@ void searchWithUTurn(const datafacade::ContiguousInternalMemoryDataFacade<Algori
     auto is_oneway_source = !(search_from_forward_node && search_from_reverse_node);
     auto is_oneway_target = !(search_to_forward_node && search_to_reverse_node);
     // we only enable loops here if we can't search from forward to backward node
-    auto needs_loop_forwards = is_oneway_source && needsLoopForward(source_phantom, target_phantom);
+    auto needs_loop_forwad =
+        is_oneway_source && ch::needsLoopForward(source_phantom, target_phantom);
     auto needs_loop_backwards =
-        is_oneway_target && needsLoopBackwards(source_phantom, target_phantom);
+        is_oneway_target && ch::needsLoopBackwards(source_phantom, target_phantom);
 
     forward_core_heap.Clear();
     reverse_core_heap.Clear();
     BOOST_ASSERT(forward_core_heap.Size() == 0);
     BOOST_ASSERT(reverse_core_heap.Size() == 0);
-    search(facade,
-           forward_heap,
-           reverse_heap,
-           forward_core_heap,
-           reverse_core_heap,
-           new_total_weight,
-           leg_packed_path,
-           needs_loop_forwards,
-           needs_loop_backwards,
-           {source_phantom, target_phantom});
+    ch::search(facade,
+               forward_heap,
+               reverse_heap,
+               forward_core_heap,
+               reverse_core_heap,
+               new_total_weight,
+               leg_packed_path,
+               needs_loop_forwad,
+               needs_loop_backwards);
 
     // if no route is found between two parts of the via-route, the entire route becomes
     // invalid. Adding to invalid edge weight sadly doesn't return an invalid edge weight. Here
@@ -100,12 +100,12 @@ void searchWithUTurn(const datafacade::ContiguousInternalMemoryDataFacade<Algori
 // searches shortest path between:
 // source forward/reverse -> target forward
 // source forward/reverse -> target reverse
-template <typename Algorithm>
-void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-            typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-            typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-            typename SearchEngineData<Algorithm>::QueryHeap &forward_core_heap,
-            typename SearchEngineData<Algorithm>::QueryHeap &reverse_core_heap,
+template <typename AlgorithmT>
+void search(const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &facade,
+            QueryHeap &forward_heap,
+            QueryHeap &reverse_heap,
+            QueryHeap &forward_core_heap,
+            QueryHeap &reverse_core_heap,
             const bool search_from_forward_node,
             const bool search_from_reverse_node,
             const bool search_to_forward_node,
@@ -148,16 +148,15 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &fac
         reverse_core_heap.Clear();
         BOOST_ASSERT(forward_core_heap.Size() == 0);
         BOOST_ASSERT(reverse_core_heap.Size() == 0);
-        search(facade,
-               forward_heap,
-               reverse_heap,
-               forward_core_heap,
-               reverse_core_heap,
-               new_total_weight_to_forward,
-               leg_packed_path_forward,
-               needsLoopForward(source_phantom, target_phantom),
-               routing_algorithms::DO_NOT_FORCE_LOOP,
-               {source_phantom, target_phantom});
+        ch::search(facade,
+                   forward_heap,
+                   reverse_heap,
+                   forward_core_heap,
+                   reverse_core_heap,
+                   new_total_weight_to_forward,
+                   leg_packed_path_forward,
+                   ch::needsLoopForward(source_phantom, target_phantom),
+                   DO_NOT_FORCE_LOOP);
     }
 
     if (search_to_reverse_node)
@@ -187,21 +186,19 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &fac
         reverse_core_heap.Clear();
         BOOST_ASSERT(forward_core_heap.Size() == 0);
         BOOST_ASSERT(reverse_core_heap.Size() == 0);
-        search(facade,
-               forward_heap,
-               reverse_heap,
-               forward_core_heap,
-               reverse_core_heap,
-               new_total_weight_to_reverse,
-               leg_packed_path_reverse,
-               routing_algorithms::DO_NOT_FORCE_LOOP,
-               needsLoopBackwards(source_phantom, target_phantom),
-               {source_phantom, target_phantom});
+        ch::search(facade,
+                   forward_heap,
+                   reverse_heap,
+                   forward_core_heap,
+                   reverse_core_heap,
+                   new_total_weight_to_reverse,
+                   leg_packed_path_reverse,
+                   DO_NOT_FORCE_LOOP,
+                   ch::needsLoopBackwards(source_phantom, target_phantom));
     }
 }
 
-template <typename Algorithm>
-void unpackLegs(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void unpackLegs(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                 const std::vector<PhantomNodes> &phantom_nodes_vector,
                 const std::vector<NodeID> &total_packed_path,
                 const std::vector<std::size_t> &packed_leg_begin,
@@ -217,11 +214,11 @@ void unpackLegs(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
         auto leg_begin = total_packed_path.begin() + packed_leg_begin[current_leg];
         auto leg_end = total_packed_path.begin() + packed_leg_begin[current_leg + 1];
         const auto &unpack_phantom_node_pair = phantom_nodes_vector[current_leg];
-        unpackPath(facade,
-                   leg_begin,
-                   leg_end,
-                   unpack_phantom_node_pair,
-                   raw_route_data.unpacked_path_segments[current_leg]);
+        ch::unpackPath(facade,
+                       leg_begin,
+                       leg_end,
+                       unpack_phantom_node_pair,
+                       raw_route_data.unpacked_path_segments[current_leg]);
 
         raw_route_data.source_traversed_in_reverse.push_back(
             (*leg_begin != phantom_nodes_vector[current_leg].source_phantom.forward_segment_id.id));
@@ -230,14 +227,13 @@ void unpackLegs(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
              phantom_nodes_vector[current_leg].target_phantom.forward_segment_id.id));
     }
 }
-}
 
-template <typename Algorithm>
+template <typename AlgorithmT>
 InternalRouteResult
-shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   const std::vector<PhantomNodes> &phantom_nodes_vector,
-                   const boost::optional<bool> continue_straight_at_waypoint)
+shortestPathSearchImpl(SearchEngineData &engine_working_data,
+                       const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &facade,
+                       const std::vector<PhantomNodes> &phantom_nodes_vector,
+                       const boost::optional<bool> continue_straight_at_waypoint)
 {
     InternalRouteResult raw_route_data;
     raw_route_data.segment_end_coordinates = phantom_nodes_vector;
@@ -248,10 +244,10 @@ shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
     engine_working_data.InitializeOrClearSecondThreadLocalStorage(facade.GetNumberOfNodes());
 
-    auto &forward_heap = *engine_working_data.forward_heap_1;
-    auto &reverse_heap = *engine_working_data.reverse_heap_1;
-    auto &forward_core_heap = *engine_working_data.forward_heap_2;
-    auto &reverse_core_heap = *engine_working_data.reverse_heap_2;
+    QueryHeap &forward_heap = *(engine_working_data.forward_heap_1);
+    QueryHeap &reverse_heap = *(engine_working_data.reverse_heap_1);
+    QueryHeap &forward_core_heap = *(engine_working_data.forward_heap_2);
+    QueryHeap &reverse_core_heap = *(engine_working_data.reverse_heap_2);
 
     int total_weight_to_forward = 0;
     int total_weight_to_reverse = 0;
@@ -457,22 +453,7 @@ shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                  total_weight_to_reverse != INVALID_EDGE_WEIGHT);
 
     // We make sure the fastest route is always in packed_legs_to_forward
-    if (total_weight_to_forward < total_weight_to_reverse ||
-        (total_weight_to_forward == total_weight_to_reverse &&
-         total_packed_path_to_forward.size() < total_packed_path_to_reverse.size()))
-    {
-        // insert sentinel
-        packed_leg_to_forward_begin.push_back(total_packed_path_to_forward.size());
-        BOOST_ASSERT(packed_leg_to_forward_begin.size() == phantom_nodes_vector.size() + 1);
-
-        unpackLegs(facade,
-                   phantom_nodes_vector,
-                   total_packed_path_to_forward,
-                   packed_leg_to_forward_begin,
-                   total_weight_to_forward,
-                   raw_route_data);
-    }
-    else
+    if (total_weight_to_forward > total_weight_to_reverse)
     {
         // insert sentinel
         packed_leg_to_reverse_begin.push_back(total_packed_path_to_reverse.size());
@@ -485,27 +466,43 @@ shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                    total_weight_to_reverse,
                    raw_route_data);
     }
+    else
+    {
+        // insert sentinel
+        packed_leg_to_forward_begin.push_back(total_packed_path_to_forward.size());
+        BOOST_ASSERT(packed_leg_to_forward_begin.size() == phantom_nodes_vector.size() + 1);
+
+        unpackLegs(facade,
+                   phantom_nodes_vector,
+                   total_packed_path_to_forward,
+                   packed_leg_to_forward_begin,
+                   total_weight_to_forward,
+                   raw_route_data);
+    }
 
     return raw_route_data;
 }
+}
 
-template InternalRouteResult
-shortestPathSearch(SearchEngineData<ch::Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+InternalRouteResult
+shortestPathSearch(SearchEngineData &engine_working_data,
+                   const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
-                   const boost::optional<bool> continue_straight_at_waypoint);
+                   const boost::optional<bool> continue_straight_at_waypoint)
+{
+    return shortestPathSearchImpl(
+        engine_working_data, facade, phantom_nodes_vector, continue_straight_at_waypoint);
+}
 
-template InternalRouteResult
-shortestPathSearch(SearchEngineData<corech::Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+InternalRouteResult
+shortestPathSearch(SearchEngineData &engine_working_data,
+                   const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
-                   const boost::optional<bool> continue_straight_at_waypoint);
-
-template InternalRouteResult
-shortestPathSearch(SearchEngineData<mld::Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-                   const std::vector<PhantomNodes> &phantom_nodes_vector,
-                   const boost::optional<bool> continue_straight_at_waypoint);
+                   const boost::optional<bool> continue_straight_at_waypoint)
+{
+    return shortestPathSearchImpl(
+        engine_working_data, facade, phantom_nodes_vector, continue_straight_at_waypoint);
+}
 
 } // namespace routing_algorithms
 } // namespace engine