Increase ringbuffer size further - allow for many more listeners on shared memory regions.

The variable name_data_mutex is declared in a block but never used
within this block. So I've removed the variable.

.editorconfig

@@ -0,0 +1,30 @@
+# EditorConfig is awesome: http://EditorConfig.org
+#
+# NOTE: Keep settings in sync with the master .clang-format file
+#
+# top-most EditorConfig file
+root = true
+
+# CMake configuration files
+[{CMakeLists.txt,CMakeSettings.json,*.cmake}]
+indent_size = 2
+indent_style = space
+trim_trailing_whitespace = true
+
+# CI configuration files
+[{.travis.yml,appveyor.yml}]
+indent_size = 2
+indent_style = space
+trim_trailing_whitespace = true
+
+# Unix shell scripts
+[*.sh]
+end_of_line = lf
+indent_style = space
+trim_trailing_whitespace = true
+
+# Windows shell scripts
+[*.bat]
+end_of_line = crlf
+indent_style = space
+trim_trailing_whitespace = true

.github/PULL_REQUEST_TEMPLATE.md

@@ -2,13 +2,18 @@
 
 What issue is this PR targeting? If there is no issue that addresses the problem, please open a corresponding issue and link it here.
 
+Please read our [documentation](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/releasing.md) on release and version management.
+If your PR is still work in progress please attach the relevant label.
+
 ## Tasklist
- - [ ] ADD OWN TASKS HERE
+
  - [ ] CHANGELOG.md entry ([How to write a changelog entry](http://keepachangelog.com/en/1.0.0/#how))
  - [ ] update relevant [Wiki pages](https://github.com/Project-OSRM/osrm-backend/wiki)
- - [ ] add regression / cucumber cases (see docs/testing.md)
+ - [ ] add tests (see [testing documentation](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/testing.md)
  - [ ] review
  - [ ] adjust for comments
+ - [ ] cherry pick to release branch
 
 ## Requirements / Relations
+
  Link any requirements here. Other pull requests this PR is based on?

.gitignore

@@ -66,6 +66,7 @@ Thumbs.db
 ######################################
 /.vs*
 /*.local.bat
+/CMakeSettings.json
 
 # stxxl related files #
 #######################

.travis.yml

@@ -59,17 +59,18 @@ matrix:
         - ./scripts/check_taginfo.py taginfo.json profiles/car.lua
         - ${MASON} install clang-format 3.8.1
         - PATH=$(${MASON} prefix clang-format 3.8.1)/bin:${PATH} ./scripts/format.sh && ./scripts/error_on_dirty.sh
+        - node ./scripts/validate_changelog.js
         # See issue 4043
         #- npm run docs && ./scripts/error_on_dirty.sh
       after_success:
 
     - os: linux
-      compiler: "gcc-6-debug-cov"
-      addons: &gcc6
+      compiler: "gcc-7-debug-cov"
+      addons: &gcc7
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev', 'lcov']
-      env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Debug' ENABLE_COVERAGE=ON CUCUMBER_TIMEOUT=20000
+          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev', 'lcov']
+      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Debug' ENABLE_COVERAGE=ON CUCUMBER_TIMEOUT=20000
       before_script:
         - cd ${TRAVIS_BUILD_DIR}
         - lcov --directory . --zerocounters # clean cached da files
@@ -83,20 +84,20 @@ matrix:
         - bash <(curl -s https://codecov.io/bash) || echo "Codecov did not collect coverage reports"
 
     - os: linux
-      compiler: "gcc-6-debug-asan"
-      addons: &gcc6
+      compiler: "gcc-7-debug-asan"
+      addons: &gcc7
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
-      env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Debug' TARGET_ARCH='x86_64-asan' ENABLE_SANITIZER=ON CUCUMBER_TIMEOUT=20000 LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/scripts/travis/leaksanitizer.conf"
+          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
+      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Debug' TARGET_ARCH='x86_64-asan' ENABLE_SANITIZER=ON CUCUMBER_TIMEOUT=20000 LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/scripts/travis/leaksanitizer.conf"
 
     - os: linux
-      compiler: "clang-4.0-debug"
-      addons: &clang40
+      compiler: "clang-5.0-debug"
+      addons: &clang50
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-5-dev', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
-      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Debug' CUCUMBER_TIMEOUT=60000
+          packages: ['libstdc++-5-dev', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
+      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' CUCUMBER_TIMEOUT=60000
 
     - os: linux
       compiler: "mason-linux-debug-asan"
@@ -104,7 +105,7 @@ matrix:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_SANITIZER=ON LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/scripts/travis/leaksanitizer.conf"
+      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_SANITIZER=ON LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/scripts/travis/leaksanitizer.conf"
 
     # Release Builds
     - os: linux
@@ -113,80 +114,70 @@ matrix:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON RUN_CLANG_FORMAT=ON ENABLE_LTO=ON
+      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON RUN_CLANG_FORMAT=ON ENABLE_LTO=ON
 
     - os: linux
-      compiler: "gcc-6-release"
-      addons: &gcc6
+      compiler: "gcc-7-release"
+      addons: &gcc7
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
-      env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release'
+          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
+      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release'
 
     - os: linux
-      compiler: "gcc-6-release-i686"
+      compiler: "gcc-7-release-i686"
       env: >
-        TARGET_ARCH='i686' CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release'
+        TARGET_ARCH='i686' CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release'
         CFLAGS='-m32 -msse2 -mfpmath=sse' CXXFLAGS='-m32 -msse2 -mfpmath=sse'
 
     - os: linux
-      compiler: "gcc-6-stxxl"
-      addons: &gcc6
+      compiler: "gcc-7-stxxl"
+      addons: &gcc7
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'libbz2-dev', 'libstxxl-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
-      env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release' ENABLE_STXXL=On
+          packages: ['g++-7', 'libbz2-dev', 'libstxxl-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
+      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release' ENABLE_STXXL=On
 
     - os: linux
-      compiler: "gcc-4.9-release"
+      compiler: "gcc-5-release"
       addons: &gcc49
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.9', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev', 'ccache']
-      env: CCOMPILER='gcc-4.9' CXXCOMPILER='g++-4.9' BUILD_TYPE='Release'
+          packages: ['g++-5', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev', 'ccache']
+      env: CCOMPILER='gcc-5' CXXCOMPILER='g++-5' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: "gcc-6-release"
+      addons: &gcc49
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev', 'ccache']
+      env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release'
 
     - os: osx
-      osx_image: xcode8.2
-      compiler: "mason-osx-release"
+      osx_image: xcode9.2
+      compiler: "mason-osx-release-node-8"
+      # we use the xcode provides clang and don't install our own
+      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="8"
+      after_success:
+        - ./scripts/travis/publish.sh
+
+    - os: osx
+      osx_image: xcode9.2
+      compiler: "mason-osx-release-node-4"
       # we use the xcode provides clang and don't install our own
       env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="4"
       after_success:
         - ./scripts/travis/publish.sh
 
-    - os: osx
-      osx_image: xcode8.2
-      compiler: "mason-osx-release"
-      # we use the xcode provides clang and don't install our own
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="6"
-      after_success:
-        - ./scripts/travis/publish.sh
-
-      # Disabled because of CI slowness
-      #- os: linux
-      #- compiler: clang
-      #- addons: &clang40
-      #-   apt:
-      #-     sources: ['llvm-toolchain-trusty-4.0', 'ubuntu-toolchain-r-test']
-      #-     packages: ['clang-4.0', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
-      #- env: CCOMPILER='clang-4.0' CXXCOMPILER='clang++-4.0' BUILD_TYPE='Release'
-
     # Shared Library
     - os: linux
-      compiler: "gcc-6-release-shared"
-      addons: &gcc6
+      compiler: "gcc-7-release-shared"
+      addons: &gcc7
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
-      env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
-
-      # Disabled because CI slowness
-      #- os: linux
-      #- compiler: clang
-      #- addons: &clang40
-      #-   apt:
-      #-     sources: ['llvm-toolchain-trusty-4.0', 'ubuntu-toolchain-r-test']
-      #-     packages: ['clang-4.0', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
-      #- env: CCOMPILER='clang-4.0' CXXCOMPILER='clang++-4.0' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
+          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
+      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
 
     # Node build jobs. These skip running the tests.
     - os: linux
@@ -196,7 +187,7 @@ matrix:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3
+      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="4"
       install:
         - pushd ${OSRM_BUILD_DIR}
         - |
@@ -215,60 +206,12 @@ matrix:
 
     - os: linux
       sudo: false
-      compiler: "node-4-mason-linux-release"
+      compiler: "node-4-mason-linux-debug"
       addons:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-6-mason-linux-release"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="6"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-6-mason-linux-release"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="6"
+      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="4"
       install:
         - pushd ${OSRM_BUILD_DIR}
         - |
@@ -292,7 +235,7 @@ matrix:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="8"
+      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="8"
       install:
         - pushd ${OSRM_BUILD_DIR}
         - |
@@ -311,12 +254,12 @@ matrix:
 
     - os: linux
       sudo: false
-      compiler: "node-6-mason-linux-release"
+      compiler: "node-8-mason-linux-debug"
       addons:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="8"
+      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="8"
       install:
         - pushd ${OSRM_BUILD_DIR}
         - |
@@ -431,7 +374,7 @@ script:
   - ./unit_tests/engine-tests
   - ./unit_tests/util-tests
   - ./unit_tests/server-tests
-  - ./unit_tests/partition-tests
+  - ./unit_tests/partitioner-tests
   - |
     if [ -z "${ENABLE_SANITIZER}" ] && [ "$TARGET_ARCH" != "i686" ]; then
       npm run nodejs-tests

CHANGELOG.md

@@ -1,10 +1,110 @@
 # UNRELEASED
+  - Changes from 5.18.0:
+    - Optimizations:
+      - CHANGED: Map matching is now almost twice as fast. [#5060](https://github.com/Project-OSRM/osrm-backend/pull/5060)
+    - Bugfixes:
+      - FIXED: collapsing of ExitRoundabout instructions [#5114](https://github.com/Project-OSRM/osrm-backend/issues/5114)
+      - FIXED: negative distances in table plugin annotation [#5106](https://github.com/Project-OSRM/osrm-backend/issues/5106)
+
+# 5.18.0
+  - Changes from 5.17.0:
+    - Features:
+      - ADDED: `table` plugin now optionally returns `distance` matrix as part of response [#4990](https://github.com/Project-OSRM/osrm-backend/pull/4990)
+      - ADDED: New optional parameter `annotations` for `table` that accepts `distance`, `duration`, or both `distance,duration` as values [#4990](https://github.com/Project-OSRM/osrm-backend/pull/4990)
+    - Infrastructure:
+      - ADDED: Updated libosmium and added protozero and vtzero libraries [#5037](https://github.com/Project-OSRM/osrm-backend/pull/5037)
+      - CHANGED: Use vtzero library in tile plugin [#4686](https://github.com/Project-OSRM/osrm-backend/pull/4686)
+    - Profile:
+      - ADDED: Bicycle profile now returns classes for ferry and tunnel routes. [#5054](https://github.com/Project-OSRM/osrm-backend/pull/5054)
+      - ADDED: Bicycle profile allows to exclude ferry routes (default to not enabled) [#5054](https://github.com/Project-OSRM/osrm-backend/pull/5054)
+
+# 5.17.1
+  - Changes from 5.17.0:
+    - Bugfixes:
+      - FIXED: Do not combine a segregated edge with a roundabout [#5039](https://github.com/Project-OSRM/osrm-backend/issues/5039)
+
+# 5.17.0
+  - Changes from 5.16.0:
+    - Bugfixes:
+      - FIXED: deduplication of route steps when waypoints are used [#4909](https://github.com/Project-OSRM/osrm-backend/issues/4909)
+      - FIXED: Use smaller range for U-turn angles in map-matching [#4920](https://github.com/Project-OSRM/osrm-backend/pull/4920)
+      - FIXED: Remove the last short annotation segment in `trimShortSegments` [#4946](https://github.com/Project-OSRM/osrm-backend/pull/4946)
+      - FIXED: Properly calculate annotations for speeds, durations and distances when waypoints are used with mapmatching [#4949](https://github.com/Project-OSRM/osrm-backend/pull/4949)
+      - FIXED: Don't apply unimplemented SH and PH conditions in OpeningHours and add inversed date ranges [#4992](https://github.com/Project-OSRM/osrm-backend/issues/4992)
+      - FIXED: integer overflow in `DynamicGraph::Renumber` [#5021](https://github.com/Project-OSRM/osrm-backend/pull/5021)
+    - Profile:
+      - CHANGED: Handle oneways in get_forward_backward_by_key [#4929](https://github.com/Project-OSRM/osrm-backend/pull/4929)
+      - FIXED: Do not route against oneway road if there is a cycleway in the wrong direction; also review bike profile [#4943](https://github.com/Project-OSRM/osrm-backend/issues/4943)
+      - CHANGED: Make cyclability weighting of the bike profile prefer safer routes more strongly [#5015](https://github.com/Project-OSRM/osrm-backend/issues/5015)
+    - Guidance:
+      - CHANGED: Don't use obviousness for links bifurcations [#4929](https://github.com/Project-OSRM/osrm-backend/pull/4929)
+      - FIXED: Adjust Straight direction modifiers of side roads in driveway handler [#4929](https://github.com/Project-OSRM/osrm-backend/pull/4929)
+      - CHANGED: Added post process logic to collapse segregated turn instructions [#4925](https://github.com/Project-OSRM/osrm-backend/pull/4925)
+      - ADDED: Maneuver relation now supports `straight` as a direction [#4995](https://github.com/Project-OSRM/osrm-backend/pull/4995)
+      - FIXED: Support spelling maneuver relation with British spelling [#4950](https://github.com/Project-OSRM/osrm-backend/issues/4950)
+    - Tools:
+      - ADDED: `osrm-routed` accepts a new property `--memory_file` to store memory in a file on disk. [#4881](https://github.com/Project-OSRM/osrm-backend/pull/4881)
+      - ADDED: `osrm-datastore` accepts a new parameter `--dataset-name` to select the name of the dataset. [#4982](https://github.com/Project-OSRM/osrm-backend/pull/4982)
+      - ADDED: `osrm-datastore` accepts a new parameter `--list` to list all datasets loaded into memory. [#4982](https://github.com/Project-OSRM/osrm-backend/pull/4982)
+      - ADDED: `osrm-datastore` accepts a new parameter `--only-metric` to only reload the data that can be updated by a weight update (reduces memory for traffic updates). [#5002](https://github.com/Project-OSRM/osrm-backend/pull/5002)
+      - ADDED: `osrm-routed` accepts a new parameter `--dataset-name` to select the shared-memory dataset to use. [#4982](https://github.com/Project-OSRM/osrm-backend/pull/4982)
+    - NodeJS:
+      - ADDED: `OSRM` object accepts a new option `memory_file` that stores the memory in a file on disk. [#4881](https://github.com/Project-OSRM/osrm-backend/pull/4881)
+      - ADDED: `OSRM` object accepts a new option `dataset_name` to select the shared-memory dataset. [#4982](https://github.com/Project-OSRM/osrm-backend/pull/4982)
+    - Internals
+      - CHANGED: Updated segregated intersection identification [#4845](https://github.com/Project-OSRM/osrm-backend/pull/4845) [#4968](https://github.com/Project-OSRM/osrm-backend/pull/4968)
+      - REMOVED: Remove `.timestamp` file since it was unused [#4960](https://github.com/Project-OSRM/osrm-backend/pull/4960)
+    - Documentation:
+      - ADDED: Add documentation about OSM node ids in nearest service response [#4436](https://github.com/Project-OSRM/osrm-backend/pull/4436)
+    - Performance
+      - FIXED: Speed up response time when lots of legs exist and geojson is used with `steps=true` [#4936](https://github.com/Project-OSRM/osrm-backend/pull/4936)
+      - FIXED: Return iterators instead of vectors in datafacade_base functions [#4969](https://github.com/Project-OSRM/osrm-backend/issues/4969)
+    - Misc:
+      - ADDED: expose name for datasource annotations as metadata [#4973](https://github.com/Project-OSRM/osrm-backend/pull/4973)
+
+# 5.16.0
+  - Changes from 5.15.2:
+    - Guidance
+      - ADDED #4676: Support for maneuver override relation, allowing data-driven overrides for turn-by-turn instructions [#4676](https://github.com/Project-OSRM/osrm-backend/pull/4676)
+      - CHANGED #4830: Announce reference change if names are empty
+      - CHANGED #4835: MAXIMAL_ALLOWED_SEPARATION_WIDTH increased to 12 meters
+      - CHANGED #4842: Lower priority links from a motorway now are used as motorway links [#4842](https://github.com/Project-OSRM/osrm-backend/pull/4842)
+      - CHANGED #4895: Use ramp bifurcations as fork intersections [#4895](https://github.com/Project-OSRM/osrm-backend/issues/4895)
+      - CHANGED #4893: Handle motorway forks with links as normal motorway intersections[#4893](https://github.com/Project-OSRM/osrm-backend/issues/4893)
+      - FIXED #4905: Check required tags of `maneuver` relations [#4905](https://github.com/Project-OSRM/osrm-backend/pull/4905)
+    - Profile:
+      - FIXED: `highway=service` will now be used for restricted access, `access=private` is still disabled for snapping.
+      - ADDED #4775: Exposes more information to the turn function, now being able to set turn weights with highway and access information of the turn as well as other roads at the intersection [#4775](https://github.com/Project-OSRM/osrm-backend/issues/4775)
+      - FIXED #4763: Add support for non-numerical units in car profile for maxheight [#4763](https://github.com/Project-OSRM/osrm-backend/issues/4763)
+      - ADDED #4872: Handling of `barrier=height_restrictor` nodes [#4872](https://github.com/Project-OSRM/osrm-backend/pull/4872)
+
+# 5.15.2
+  - Changes from 5.15.1:
+    - Features:
+        - ADDED: Exposed the waypoints parameter in the node bindings interface
+    - Bugfixes:
+        - FIXED: Segfault causing bug in leg collapsing map matching when traversing edges in reverse
+
+# 5.15.1
+  - Changes from 5.15.0:
+    - Bugfixes:
+      - FIXED: Segfault in map matching when RouteLeg collapsing code is run on a match with multiple submatches
+    - Guidance:
+      - Set type of trivial intersections where classes change to Suppressed instead of NoTurn
+
+# 5.15.0
   - Changes from 5.14.3:
     - Bugfixes:
       - FIXED #4704: Fixed regression in bearings reordering introduced in 5.13 [#4704](https://github.com/Project-OSRM/osrm-backend/issues/4704)
       - FIXED #4781: Fixed overflow exceptions in percent-encoding parsing
+      - FIXED #4770: Fixed exclude flags for single toll road scenario
+      - FIXED #4283: Fix overflow on zero duration segments
+      - FIXED #4804: Ignore no_*_on_red turn restrictions
     - Guidance:
       - CHANGED #4706: Guidance refactoring step to decouple intersection connectivity analysis and turn instructions generation [#4706](https://github.com/Project-OSRM/osrm-backend/pull/4706)
+      - CHANGED #3491: Refactor `isThroughStreet`/Intersection options
+    - Profile:
+      - ADDED: `tunnel` as a new class in car profile so that sections of the route with tunnel tags will be marked as such
 
 # 5.14.3
   - Changes from 5.14.2:

CMakeLists.txt

@@ -1,5 +1,4 @@
-cmake_minimum_required(VERSION 2.8.11)
-# we depend on 2.8.11 introducing target_include_directories
+cmake_minimum_required(VERSION 3.1)
 
 if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE)
   message(FATAL_ERROR "In-source builds are not allowed.
@@ -43,7 +42,6 @@ if(ENABLE_MASON)
   set(MASON_LUA_VERSION "5.2.4")
   set(MASON_BZIP2_VERSION "1.0.6")
   set(MASON_TBB_VERSION "2017_U7")
-  set(MASON_LIBSHP_VERSION "1.3.0")
 
   message(STATUS "Enabling mason")
 
@@ -60,12 +58,26 @@ if (POLICY CMP0048)
   cmake_policy(SET CMP0048 OLD)
 endif()
 project(OSRM C CXX)
-set(OSRM_VERSION_MAJOR 5)
-set(OSRM_VERSION_MINOR 15)
-set(OSRM_VERSION_PATCH 0)
-set(OSRM_VERSION "${OSRM_VERSION_MAJOR}.${OSRM_VERSION_MINOR}.${OSRM_VERSION_PATCH}")
 
-add_definitions(-DOSRM_PROJECT_DIR="${CMAKE_CURRENT_SOURCE_DIR}")
+include(JSONParser)
+file(READ "package.json" packagejsonraw)
+sbeParseJson(packagejson packagejsonraw)
+
+if (packagejson.version MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)")
+    set(OSRM_VERSION_MAJOR ${CMAKE_MATCH_1})
+    set(OSRM_VERSION_MINOR ${CMAKE_MATCH_2})
+    set(OSRM_VERSION_PATCH ${CMAKE_MATCH_3})
+
+    set(OSRM_VERSION "${OSRM_VERSION_MAJOR}.${OSRM_VERSION_MINOR}.${OSRM_VERSION_PATCH}")
+else()
+    message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible X.Y.Z, but found ${packagejson.version}")
+endif()
+
+if (MSVC)
+  add_definitions("-DOSRM_PROJECT_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}\"")
+else()
+  add_definitions(-DOSRM_PROJECT_DIR="${CMAKE_CURRENT_SOURCE_DIR}")
+endif()
 
 # these two functions build up custom variables:
 #   DEPENDENCIES_INCLUDE_DIRS and OSRM_DEFINES
@@ -102,10 +114,10 @@ if(WIN32 AND MSVC_VERSION LESS 1900)
   message(FATAL_ERROR "Building with Microsoft compiler needs Latest Visual Studio 2015 (Community or better)")
 endif()
 
-# Strictly require GCC>=4.9 and Clang>=3.4 - GCC 4.8 is already too old for C++14.
+# Strictly require GCC>=5.0 and Clang>=3.4 - GCC 4.8 is already too old for C++14.
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
-    message(FATAL_ERROR "GCC>=4.9 required. In case you are on Ubuntu upgrade via ppa:ubuntu-toolchain-r/test")
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
+    message(FATAL_ERROR "GCC>=5.0 required. In case you are on Ubuntu upgrade via ppa:ubuntu-toolchain-r/test")
   endif()
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
@@ -126,7 +138,8 @@ configure_file(
 )
 file(GLOB UtilGlob src/util/*.cpp src/util/*/*.cpp)
 file(GLOB ExtractorGlob src/extractor/*.cpp src/extractor/*/*.cpp)
-file(GLOB PartitionerGlob src/partition/*.cpp)
+file(GLOB GuidanceGlob src/guidance/*.cpp src/extractor/intersection/*.cpp)
+file(GLOB PartitionerGlob src/partitioner/*.cpp)
 file(GLOB CustomizerGlob src/customize/*.cpp)
 file(GLOB ContractorGlob src/contractor/*.cpp)
 file(GLOB UpdaterGlob src/updater/*.cpp)
@@ -137,6 +150,7 @@ file(GLOB ErrorcodesGlob src/osrm/errorcodes.cpp)
 
 add_library(UTIL OBJECT ${UtilGlob})
 add_library(EXTRACTOR OBJECT ${ExtractorGlob})
+add_library(GUIDANCE OBJECT ${GuidanceGlob})
 add_library(PARTITIONER OBJECT ${PartitionerGlob})
 add_library(CUSTOMIZER OBJECT ${CustomizerGlob})
 add_library(CONTRACTOR OBJECT ${ContractorGlob})
@@ -152,14 +166,15 @@ add_executable(osrm-partition src/tools/partition.cpp)
 add_executable(osrm-customize src/tools/customize.cpp)
 add_executable(osrm-contract src/tools/contract.cpp)
 add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
-add_executable(osrm-datastore src/tools/store.cpp $<TARGET_OBJECTS:UTIL>)
-add_library(osrm src/osrm/osrm.cpp $<TARGET_OBJECTS:ENGINE> $<TARGET_OBJECTS:UTIL> $<TARGET_OBJECTS:STORAGE>)
+add_executable(osrm-datastore src/tools/store.cpp $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
+add_library(osrm src/osrm/osrm.cpp $<TARGET_OBJECTS:ENGINE> $<TARGET_OBJECTS:STORAGE> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
 add_library(osrm_contract src/osrm/contractor.cpp $<TARGET_OBJECTS:CONTRACTOR> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm_extract src/osrm/extractor.cpp $<TARGET_OBJECTS:EXTRACTOR> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm_partition $<TARGET_OBJECTS:PARTITIONER> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm_customize $<TARGET_OBJECTS:CUSTOMIZER> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm_update $<TARGET_OBJECTS:UPDATER> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm_store $<TARGET_OBJECTS:STORAGE> $<TARGET_OBJECTS:UTIL>)
+add_library(osrm_extract src/osrm/extractor.cpp $<TARGET_OBJECTS:EXTRACTOR> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
+add_library(osrm_guidance $<TARGET_OBJECTS:GUIDANCE> $<TARGET_OBJECTS:UTIL>)
+add_library(osrm_partition src/osrm/partitioner.cpp $<TARGET_OBJECTS:PARTITIONER> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
+add_library(osrm_customize src/osrm/customizer.cpp $<TARGET_OBJECTS:CUSTOMIZER> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
+add_library(osrm_update $<TARGET_OBJECTS:UPDATER> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
+add_library(osrm_store $<TARGET_OBJECTS:STORAGE> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
 
 if(ENABLE_GOLD_LINKER)
     execute_process(COMMAND ${CMAKE_C_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
@@ -256,8 +271,7 @@ if(CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CM
     endif()
 
     # Since gcc 4.9 the LTO format is non-standart ('slim'), so we need to use the build-in tools
-    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND
-        NOT "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9.0" AND NOT MINGW)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND NOT MINGW)
       find_program(GCC_AR gcc-ar)
       find_program(GCC_RANLIB gcc-ranlib)
       if ("${GCC_AR}" STREQUAL "GCC_AR-NOTFOUND" OR "${GCC_RANLIB}" STREQUAL "GCC_RANLIB-NOTFOUND")
@@ -285,12 +299,6 @@ if(CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CM
         set(CMAKE_RANLIB ${LLVM_RANLIB})
       endif()
     endif()
-
-    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9.0")
-      message(STATUS "Disabling LTO on GCC < 4.9.0 since it is broken, see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57038")
-      set(CMAKE_CXX_FLAGS "${OLD_CXX_FLAGS}")
-      set(ENABLE_LTO Off)
-    endif()
   endif()
 endif()
 
@@ -317,8 +325,9 @@ if (ENABLE_SANITIZER)
 endif()
 
 # Configuring compilers
+set(OSRM_WARNING_FLAGS "-Werror=all -Werror=extra  -Werror=uninitialized -Werror=unreachable-code -Werror=unused-variable -Werror=unreachable-code -Wno-error=cpp -Wpedantic")
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wuninitialized -Wunreachable-code -Wstrict-overflow=2 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fPIC -fcolor-diagnostics -ftemplate-depth=1024 -Wno-unused-command-line-argument")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OSRM_WARNING_FLAGS} -Werror=strict-overflow=2 -Wno-error=unused-local-typedef -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fPIC -fcolor-diagnostics -ftemplate-depth=1024 -Wno-unused-command-line-argument")
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
   set(COLOR_FLAG "-fdiagnostics-color=auto")
   check_cxx_compiler_flag("-fdiagnostics-color=auto" HAS_COLOR_FLAG)
@@ -326,7 +335,8 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
     set(COLOR_FLAG "")
   endif()
   # using GCC
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wuninitialized -Wunreachable-code -Wstrict-overflow=1 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 ${COLOR_FLAG} -fPIC -ftemplate-depth=1024")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OSRM_WARNING_FLAGS} -Werror=strict-overflow=1 -Wno-error=maybe-uninitialized -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 ${COLOR_FLAG} -fPIC -ftemplate-depth=1024")
+
   if(WIN32) # using mingw
     add_dependency_defines(-DWIN32)
     set(OPTIONAL_SOCKET_LIBS ws2_32 wsock32)
@@ -406,11 +416,30 @@ if(UNIX AND NOT APPLE)
   set(MAYBE_RT_LIBRARY -lrt)
 endif()
 
-# Disallow deprecated protozero APIs
-add_definitions(-DPROTOZERO_STRICT_API)
-
 find_package(Threads REQUIRED)
 
+# Third-party libraries
+set(RAPIDJSON_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/rapidjson/include")
+include_directories(SYSTEM ${RAPIDJSON_INCLUDE_DIR})
+
+set(MICROTAR_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src")
+include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})
+
+set(MBXGEOM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/geometry.hpp-0.9.2/include")
+include_directories(SYSTEM ${MBXGEOM_INCLUDE_DIR})
+set(CHEAPRULER_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/cheap-ruler-cpp-2.5.4/include")
+include_directories(SYSTEM ${CHEAPRULER_INCLUDE_DIR})
+
+add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
+set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+set(PROTOZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/protozero/include")
+include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
+
+set(VTZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/vtzero/include")
+include_directories(SYSTEM ${VTZERO_INCLUDE_DIR})
+
+
 # if mason is enabled no find_package calls are made
 # to ensure that we are only compiling and linking against
 # fully portable mason packages
@@ -485,9 +514,6 @@ if(ENABLE_MASON)
   # note: we avoid calling find_package(Osmium ...) here to ensure that the
   # expat and bzip2 are used from mason rather than the system
   include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include)
-
-  include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/rapidjson/include)
-
 else()
 
   find_package(Boost 1.54 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
@@ -545,10 +571,6 @@ else()
   endif()
   find_package(Osmium REQUIRED COMPONENTS io)
   include_directories(SYSTEM ${OSMIUM_INCLUDE_DIR})
-
-  set(RAPIDJSON_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/rapidjson/include")
-  include_directories(SYSTEM ${RAPIDJSON_INCLUDE_DIR})
-
 endif()
 
 # prefix compilation with ccache by default if available and on clang or gcc
@@ -624,6 +646,12 @@ set(EXTRACTOR_LIBRARIES
     ${TBB_LIBRARIES}
     ${ZLIB_LIBRARY}
     ${MAYBE_COVERAGE_LIBRARIES})
+set(GUIDANCE_LIBRARIES
+    ${BOOST_BASE_LIBRARIES}
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${USED_LUA_LIBRARIES}
+    ${TBB_LIBRARIES}
+    ${MAYBE_COVERAGE_LIBRARIES})
 set(PARTITIONER_LIBRARIES
     ${BOOST_ENGINE_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
@@ -670,19 +698,20 @@ set(UTIL_LIBRARIES
     ${CMAKE_THREAD_LIBS_INIT}
     ${MAYBE_STXXL_LIBRARY}
     ${TBB_LIBRARIES}
-    ${MAYBE_COVERAGE_LIBRARIES})
+    ${MAYBE_COVERAGE_LIBRARIES}
+    ${ZLIB_LIBRARY})
 
 # Libraries
 target_link_libraries(osrm ${ENGINE_LIBRARIES})
 target_link_libraries(osrm_update ${UPDATER_LIBRARIES})
 target_link_libraries(osrm_contract ${CONTRACTOR_LIBRARIES} osrm_update osrm_store)
-target_link_libraries(osrm_extract ${EXTRACTOR_LIBRARIES})
+target_link_libraries(osrm_extract osrm_guidance ${EXTRACTOR_LIBRARIES})
 target_link_libraries(osrm_partition ${PARTITIONER_LIBRARIES})
 target_link_libraries(osrm_customize ${CUSTOMIZER_LIBRARIES} osrm_update osrm_store)
 target_link_libraries(osrm_store ${STORAGE_LIBRARIES})
 
 # BUILD_COMPONENTS
-add_executable(osrm-components src/tools/components.cpp $<TARGET_OBJECTS:UTIL>)
+add_executable(osrm-components src/tools/components.cpp $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
 target_link_libraries(osrm-components ${TBB_LIBRARIES} ${BOOST_BASE_LIBRARIES} ${UTIL_LIBRARIES})
 install(TARGETS osrm-components DESTINATION bin)
 
@@ -692,15 +721,6 @@ if(BUILD_TOOLS)
   target_link_libraries(osrm-io-benchmark ${BOOST_BASE_LIBRARIES})
 
   install(TARGETS osrm-io-benchmark DESTINATION bin)
-
-  find_package(Shapefile)
-  if(SHAPEFILE_FOUND AND (Boost_VERSION VERSION_GREATER 106000 OR ENABLE_MASON))
-    add_executable(osrm-extract-conditionals src/tools/extract-conditionals.cpp $<TARGET_OBJECTS:UTIL>)
-    target_include_directories(osrm-extract-conditionals PRIVATE ${LIBSHAPEFILE_INCLUDE_DIR})
-    target_link_libraries(osrm-extract-conditionals ${OSMIUM_LIBRARIES} ${BOOST_BASE_LIBRARIES} ${Boost_PROGRAM_OPTIONS_LIBRARY}
-        ${UTIL_LIBRARIES} ${BZIP2_LIBRARIES} ${ZLIB_LIBRARY} ${EXPAT_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
-    install(TARGETS osrm-extract-conditionals DESTINATION bin)
-  endif()
 endif()
 
 if (ENABLE_ASSERTIONS)
@@ -723,14 +743,14 @@ file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
 set(EngineHeader include/engine/status.hpp include/engine/engine_config.hpp include/engine/hint.hpp include/engine/bearing.hpp include/engine/approach.hpp include/engine/phantom_node.hpp)
 set(UtilHeader include/util/coordinate.hpp include/util/json_container.hpp include/util/typedefs.hpp include/util/alias.hpp include/util/exception.hpp include/util/bearing.hpp)
 set(ExtractorHeader include/extractor/extractor.hpp include/storage/io_config.hpp include/extractor/extractor_config.hpp include/extractor/travel_mode.hpp)
-set(PartitionerHeader include/partition/partitioner.hpp include/partition/partition_config.hpp)
+set(PartitionerHeader include/partitioner/partitioner.hpp include/partitioner/partitioner_config.hpp)
 set(ContractorHeader include/contractor/contractor.hpp include/contractor/contractor_config.hpp)
 set(StorageHeader include/storage/storage.hpp include/storage/io_config.hpp include/storage/storage_config.hpp)
 install(FILES ${EngineHeader} DESTINATION include/osrm/engine)
 install(FILES ${UtilHeader} DESTINATION include/osrm/util)
 install(FILES ${StorageHeader} DESTINATION include/osrm/storage)
 install(FILES ${ExtractorHeader} DESTINATION include/osrm/extractor)
-install(FILES ${PartitionerHeader} DESTINATION include/osrm/partition)
+install(FILES ${PartitionerHeader} DESTINATION include/osrm/partitioner)
 install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
 install(FILES ${LibraryGlob} DESTINATION include/osrm)
 install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
@@ -853,4 +873,4 @@ if (ENABLE_NODE_BINDINGS)
   endforeach()
   add_library(check-headers STATIC EXCLUDE_FROM_ALL ${sources})
   set_target_properties(check-headers PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${check_headers_dir})
-endif()
+endif()

README.md

@@ -9,7 +9,7 @@ High performance routing engine written in C++14 designed to run on OpenStreetMa
 The following services are available via HTTP API, C++ library interface and NodeJs wrapper:
 - Nearest - Snaps coordinates to the street network and returns the nearest matches
 - Route - Finds the fastest route between coordinates
-- Table - Computes the duration of the fastest route between all pairs of supplied coordinates
+- Table - Computes the duration or distances of the fastest route between all pairs of supplied coordinates
 - Match - Snaps noisy GPS traces to the road network in the most plausible way
 - Trip - Solves the Traveling Salesman Problem using a greedy heuristic
 - Tile - Generates Mapbox Vector Tiles with internal routing metadata
@@ -59,9 +59,14 @@ Download OpenStreetMap extracts for example from [Geofabrik](http://download.geo
 Pre-process the extract with the car profile and start a routing engine HTTP server on port 5000
 
     docker run -t -v $(pwd):/data osrm/osrm-backend osrm-extract -p /opt/car.lua /data/berlin-latest.osm.pbf
+
+The flag `-v $(pwd):/data` creates the directory `/data` inside the docker container and makes the current working directory `$(pwd)` available there. The file `/data/berlin-latest.osm.pbf` inside the container is referring to `$(pwd)/berlin-latest.osm.pbf` on the host.
+
     docker run -t -v $(pwd):/data osrm/osrm-backend osrm-partition /data/berlin-latest.osrm
     docker run -t -v $(pwd):/data osrm/osrm-backend osrm-customize /data/berlin-latest.osrm
 
+Note that `berlin-latest.osrm` has a different file extension. 
+
     docker run -t -i -p 5000:5000 -v $(pwd):/data osrm/osrm-backend osrm-routed --algorithm mld /data/berlin-latest.osrm
 
 Make requests against the HTTP server

appveyor-build.bat

@@ -161,29 +161,6 @@ XCOPY /Y corech\*.* ..\test\data\corech\
 XCOPY /Y mld\*.* ..\test\data\mld\
 unit_tests\%Configuration%\library-tests.exe
 
-IF NOT "%APPVEYOR_REPO_BRANCH%"=="master" GOTO DONE
-ECHO ========= CREATING PACKAGES ==========
-
-CD %PROJECT_DIR%\build\%Configuration%
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-SET P=%PROJECT_DIR%
-SET ZIP= %P%\osrm_%Configuration%.zip
-IF EXIST %ZIP% ECHO deleting %ZIP% && DEL /F /Q %ZIP%
-IF %ERRORLEVEL% NEQ 0 ECHO deleting %ZIP% FAILED && GOTO ERROR
-
-7z a %ZIP% *.lib *.exe *.pdb %P%/osrm-deps/libs/bin/*.dll -tzip -mx9 | %windir%\system32\FIND "ing archive"
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-CD ..\..\profiles
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-ECHO disk=c:\temp\stxxl,10000,wincall > .stxxl.txt
-7z a %ZIP% * -tzip -mx9 | %windir%\system32\FIND "ing archive"
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-GOTO DONE
-
 :ERROR
 ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 ECHO ERRORLEVEL^: %ERRORLEVEL%

appveyor.yml

@@ -29,24 +29,7 @@ before_test:
   - SET OSRM_BUILD_DIR=build\%Configuration%
   - npm test
 
-artifacts:
-  - path: osrm_Release.zip
-    name: osrm_Release.zip
-#  - path: osrm_Debug.zip
-#    name: osrm_Debug.zip
-
 branches:
   only:
     - master
 
-deploy:
-  provider: FTP
-  server:
-    secure: ef7oiQTTXFGt8NdNiOHm/uRFVrUttzyFbIlnaeHhQvw=
-  username:
-    secure: Bw+Se2GTJxA6+GtRkEc//tQSBHOuFIuJHBjFwR9cD+8=
-  password:
-    secure: eqwESZqxMXC/j5mOCpaXuw==
-  folder: /
-  enable_ssl: true
-  active_mode: false

cmake/FindShapefile.cmake

@@ -1,21 +0,0 @@
-# - Try to find Shapefile C Library
-#   http://shapelib.maptools.org/
-#
-# Exports:
-#  Shapefile_FOUND
-#  LIBSHAPEFILE_INCLUDE_DIR
-#  LIBSHAPEFILE_LIBRARY
-# Hints:
-#  LIBSHAPEFILE_LIBRARY_DIR
-
-find_path(LIBSHAPEFILE_INCLUDE_DIR
-          shapefil.h)
-
-find_library(LIBSHAPEFILE_LIBRARY
-             NAMES shp
-             HINTS "${LIBSHAPEFILE_LIBRARY_DIR}")
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Shapefile DEFAULT_MSG
-                                  LIBSHAPEFILE_LIBRARY LIBSHAPEFILE_INCLUDE_DIR)
-mark_as_advanced(LIBSHAPEFILE_INCLUDE_DIR LIBSHAPEFILE_LIBRARY)

cmake/JSONParser.cmake

@@ -0,0 +1,290 @@
+# https://github.com/sbellus/json-cmake/blob/9913da8800b95322d393894d3525d634568f305e/JSONParser.cmake
+# MIT Licensed - https://github.com/sbellus/json-cmake/blob/master/LICENSE
+
+cmake_minimum_required(VERSION 3.1)
+
+if (DEFINED JSonParserGuard)
+    return()
+endif()
+
+set(JSonParserGuard yes)
+
+macro(sbeParseJson prefix jsonString)
+    cmake_policy(PUSH)
+
+    set(json_string "${${jsonString}}")
+    string(LENGTH "${json_string}" json_jsonLen)
+    set(json_index 0)
+    set(json_AllVariables ${prefix})
+    set(json_ArrayNestingLevel 0)
+    set(json_MaxArrayNestingLevel 0)
+
+    _sbeParse(${prefix})
+    
+    unset(json_index)
+    unset(json_AllVariables)
+    unset(json_jsonLen)
+    unset(json_string)
+    unset(json_value)
+    unset(json_inValue)    
+    unset(json_name)
+    unset(json_inName)
+    unset(json_newPrefix)
+    unset(json_reservedWord)
+    unset(json_arrayIndex)
+    unset(json_char)
+    unset(json_end)
+    unset(json_ArrayNestingLevel)
+    foreach(json_nestingLevel RANGE ${json_MaxArrayNestingLevel})
+        unset(json_${json_nestingLevel}_arrayIndex)
+    endforeach()
+    unset(json_nestingLevel)
+    unset(json_MaxArrayNestingLevel)
+    
+    cmake_policy(POP)
+endmacro()
+
+macro(sbeClearJson prefix)
+    foreach(json_var ${${prefix}})
+        unset(${json_var})
+    endforeach()
+    
+    unset(${prefix})
+    unset(json_var)
+endmacro()
+
+macro(sbePrintJson prefix)
+    foreach(json_var ${${prefix}})
+        message("${json_var} = ${${json_var}}")
+    endforeach()
+endmacro()
+
+macro(_sbeParse prefix)
+
+    while(${json_index} LESS ${json_jsonLen})
+        string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+        
+        if("\"" STREQUAL "${json_char}")    
+            _sbeParseNameValue(${prefix})
+        elseif("{" STREQUAL "${json_char}")
+            _sbeMoveToNextNonEmptyCharacter()
+            _sbeParseObject(${prefix})
+        elseif("[" STREQUAL "${json_char}")
+            _sbeMoveToNextNonEmptyCharacter()
+            _sbeParseArray(${prefix})
+        endif()
+
+        if(${json_index} LESS ${json_jsonLen})
+            string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+        else()
+            break()
+        endif()
+
+        if ("}" STREQUAL "${json_char}" OR "]" STREQUAL "${json_char}")
+            break()
+        endif()
+        
+        _sbeMoveToNextNonEmptyCharacter()
+    endwhile()    
+endmacro()
+
+macro(_sbeParseNameValue prefix)
+    set(json_name "")
+    set(json_inName no)
+
+    while(${json_index} LESS ${json_jsonLen})
+        string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+        
+        # check if name ends
+        if("\"" STREQUAL "${json_char}" AND json_inName)
+            set(json_inName no)
+            _sbeMoveToNextNonEmptyCharacter()
+            if(NOT ${json_index} LESS ${json_jsonLen})
+                break()
+            endif()                
+            string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+            set(json_newPrefix ${prefix}.${json_name})
+            set(json_name "")
+            
+            if(":" STREQUAL "${json_char}")
+                _sbeMoveToNextNonEmptyCharacter()
+                if(NOT ${json_index} LESS ${json_jsonLen})
+                    break()
+                endif()                
+                string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+
+                if("\"" STREQUAL "${json_char}")    
+                    _sbeParseValue(${json_newPrefix})
+                    break()
+                elseif("{" STREQUAL "${json_char}")
+                    _sbeMoveToNextNonEmptyCharacter()
+                    _sbeParseObject(${json_newPrefix})
+                    break()
+                elseif("[" STREQUAL "${json_char}")
+                    _sbeMoveToNextNonEmptyCharacter()
+                    _sbeParseArray(${json_newPrefix})
+                    break()
+                else()
+                    # reserved word starts
+                    _sbeParseReservedWord(${json_newPrefix})
+                    break()
+                endif()
+            else()
+                # name without value
+                list(APPEND ${json_AllVariables} ${json_newPrefix})
+                set(${json_newPrefix} "")
+                break()            
+            endif()           
+        endif()
+
+        if(json_inName)
+            # remove escapes
+            if("\\" STREQUAL "${json_char}")
+                math(EXPR json_index "${json_index} + 1")
+                if(NOT ${json_index} LESS ${json_jsonLen})
+                    break()
+                endif()                
+                string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+            endif()
+        
+            set(json_name "${json_name}${json_char}")
+        endif()
+        
+        # check if name starts
+        if("\"" STREQUAL "${json_char}" AND NOT json_inName)
+            set(json_inName yes)
+        endif()
+       
+        _sbeMoveToNextNonEmptyCharacter()
+    endwhile()    
+endmacro()
+
+macro(_sbeParseReservedWord prefix)
+    set(json_reservedWord "")
+    set(json_end no)
+    while(${json_index} LESS ${json_jsonLen} AND NOT json_end)
+        string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+        
+        if("," STREQUAL "${json_char}" OR "}" STREQUAL "${json_char}" OR "]" STREQUAL "${json_char}")
+            set(json_end yes)
+        else()
+            set(json_reservedWord "${json_reservedWord}${json_char}")
+            math(EXPR json_index "${json_index} + 1")
+        endif()
+    endwhile()
+
+    list(APPEND ${json_AllVariables} ${prefix})
+    string(STRIP  "${json_reservedWord}" json_reservedWord)
+    set(${prefix} ${json_reservedWord})
+endmacro()
+
+macro(_sbeParseValue prefix)
+    cmake_policy(SET CMP0054 NEW) # turn off implicit expansions in if statement
+    
+    set(json_value "")
+    set(json_inValue no)
+    
+    while(${json_index} LESS ${json_jsonLen})
+        string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+
+        # check if json_value ends, it is ended by "
+        if("\"" STREQUAL "${json_char}" AND json_inValue)
+            set(json_inValue no)
+            
+            set(${prefix} ${json_value})
+            list(APPEND ${json_AllVariables} ${prefix})
+            _sbeMoveToNextNonEmptyCharacter()
+            break()
+        endif()
+                
+        if(json_inValue)
+             # if " is escaped consume
+            if("\\" STREQUAL "${json_char}")
+                math(EXPR json_index "${json_index} + 1")
+                if(NOT ${json_index} LESS ${json_jsonLen})
+                    break()
+                endif()                
+                string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+                if(NOT "\"" STREQUAL "${json_char}")
+                    # if it is not " then copy also escape character
+                    set(json_char "\\${json_char}")
+                endif()
+            endif()      
+              
+            _sbeAddEscapedCharacter("${json_char}")
+        endif()
+        
+        # check if value starts
+        if("\"" STREQUAL "${json_char}" AND NOT json_inValue)
+            set(json_inValue yes)
+        endif()
+        
+        math(EXPR json_index "${json_index} + 1")
+    endwhile()
+endmacro()
+
+macro(_sbeAddEscapedCharacter char)
+    string(CONCAT json_value "${json_value}" "${char}")
+endmacro()
+
+macro(_sbeParseObject prefix)
+    _sbeParse(${prefix})
+    _sbeMoveToNextNonEmptyCharacter()
+endmacro()
+
+macro(_sbeParseArray prefix)
+    math(EXPR json_ArrayNestingLevel "${json_ArrayNestingLevel} + 1")
+    set(json_${json_ArrayNestingLevel}_arrayIndex 0)
+
+    set(${prefix} "")
+    list(APPEND ${json_AllVariables} ${prefix})
+
+    while(${json_index} LESS ${json_jsonLen})
+        string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+
+        if("\"" STREQUAL "${json_char}")
+            # simple value
+            list(APPEND ${prefix} ${json_${json_ArrayNestingLevel}_arrayIndex})
+            _sbeParseValue(${prefix}_${json_${json_ArrayNestingLevel}_arrayIndex})
+        elseif("{" STREQUAL "${json_char}")
+            # object
+            _sbeMoveToNextNonEmptyCharacter()
+            list(APPEND ${prefix} ${json_${json_ArrayNestingLevel}_arrayIndex})
+            _sbeParseObject(${prefix}_${json_${json_ArrayNestingLevel}_arrayIndex})
+        else()
+            list(APPEND ${prefix} ${json_${json_ArrayNestingLevel}_arrayIndex})
+            _sbeParseReservedWord(${prefix}_${json_${json_ArrayNestingLevel}_arrayIndex})
+        endif()
+        
+        if(NOT ${json_index} LESS ${json_jsonLen})
+            break()
+        endif()
+        
+        string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+        
+        if("]" STREQUAL "${json_char}")
+            _sbeMoveToNextNonEmptyCharacter()
+            break()
+        elseif("," STREQUAL "${json_char}")
+            math(EXPR json_${json_ArrayNestingLevel}_arrayIndex "${json_${json_ArrayNestingLevel}_arrayIndex} + 1")            
+        endif()
+                
+        _sbeMoveToNextNonEmptyCharacter()
+    endwhile()    
+    
+    if(${json_MaxArrayNestingLevel} LESS ${json_ArrayNestingLevel})
+        set(json_MaxArrayNestingLevel ${json_ArrayNestingLevel})
+    endif()
+    math(EXPR json_ArrayNestingLevel "${json_ArrayNestingLevel} - 1")
+endmacro()
+
+macro(_sbeMoveToNextNonEmptyCharacter)
+    math(EXPR json_index "${json_index} + 1")
+    if(${json_index} LESS ${json_jsonLen})
+        string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+        while(${json_char} MATCHES "[ \t\n\r]" AND ${json_index} LESS ${json_jsonLen})
+            math(EXPR json_index "${json_index} + 1")
+            string(SUBSTRING "${json_string}" ${json_index} 1 json_char)
+        endwhile()
+    endif()
+endmacro()

cucumber.js

@@ -3,5 +3,5 @@ module.exports = {
     verify: '--strict --tags ~@stress --tags ~@todo --tags ~@mld-only -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 --require features/support --require features/step_definitions -f progress'
+    mld: '--strict --tags ~@stress --tags ~@todo --tags ~@ch --require features/support --require features/step_definitions -f progress'
 };

data/driving_side.geojson

@@ -10,43 +10,6 @@
         "type": "Polygon",
         "coordinates": [
           [
-            [
-              -60.07324218749999,
-              12.71000912504629
-            ],
-            [
-              -59.0185546875,
-              12.71000912504629
-            ],
-            [
-              -59.0185546875,
-              13.694024844701644
-            ],
-            [
-              -60.07324218749999,
-              13.694024844701644
-            ],
-            [
-              -60.07324218749999,
-              12.71000912504629
-            ]
-          ]
-        ]
-      }
-    },
-    {
-      "type": "Feature",
-      "properties": {
-        "driving_side": "left"
-      },
-      "geometry": {
-        "type": "Polygon",
-        "coordinates": [
-          [
-            [
-              164.3678069114686,
-              -30.759557257019974
-            ],
             [
               159.78515624999997,
               -21.943045533438166
@@ -359,10 +322,6 @@
               92.56116628646856,
               15.147674168282906
             ],
-            [
-              88.78186941146853,
-              12.158807474538182
-            ],
             [
               90.71546316146853,
               0.759386240320313
@@ -392,8 +351,8 @@
               -33.73235247373941
             ],
             [
-              164.3678069114686,
-              -30.759557257019974
+              159.78515624999997,
+              -21.943045533438166
             ]
           ]
         ]
@@ -409,12 +368,8 @@
         "coordinates": [
           [
             [
-              147.381591796875,
-              43.26920624914964
-            ],
-            [
-              147.06298828125,
-              44.22158376545796
+              147.15087890625003,
+              44.13885576756881
             ],
             [
               145.52490234375,
@@ -432,37 +387,13 @@
               141.48193359375,
               45.836454050187726
             ],
-            [
-              140.38330078125,
-              45.47554027158593
-            ],
-            [
-              138.021240234375,
-              41.08763212467916
-            ],
             [
               135.0439453125,
               37.71859032558816
             ],
             [
-              132.462158203125,
-              36.37706783983682
-            ],
-            [
-              130.53955078125,
-              34.71452466170392
-            ],
-            [
-              129.00146484375,
-              33.568861182555565
-            ],
-            [
-              127.891845703125,
-              32.54681317351514
-            ],
-            [
-              127.606201171875,
-              30.240086360983426
+              127.88085937500001,
+              32.565333160841035
             ],
             [
               125.61767578124999,
@@ -481,28 +412,12 @@
               25.284437746983055
             ],
             [
-              136.3623046875,
-              30.41078179084589
+              141.36108398437503,
+              33.394759218577995
             ],
             [
-              143.67919921874997,
-              33.925129700072
-            ],
-            [
-              144.25048828125,
-              39.605688178320804
-            ],
-            [
-              147.45849609375,
-              42.48830197960227
-            ],
-            [
-              147.94189453125,
-              43.13306116240612
-            ],
-            [
-              147.381591796875,
-              43.26920624914964
+              147.15087890625003,
+              44.13885576756881
             ]
           ]
         ]
@@ -517,18 +432,6 @@
         "type": "Polygon",
         "coordinates": [
           [
-            [
-              2.63671875,
-              52.119998657638156
-            ],
-            [
-              2.5048828125,
-              53.527247970102465
-            ],
-            [
-              -0.0439453125,
-              56.992882804633986
-            ],
             [
               1.9116210937499998,
               61.19621314083867
@@ -538,24 +441,12 @@
               61.990587736204105
             ],
             [
-              -7.6025390625,
-              59.678835236960765
+              -12.54638671875,
+              55.94919982336746
             ],
             [
-              -12.28271484375,
-              55.51619215717891
-            ],
-            [
-              -12.19482421875,
-              51.2206474303833
-            ],
-            [
-              -6.591796875,
-              49.403824657885124
-            ],
-            [
-              -3.251953125,
-              49.25346477497736
+              -12.260742187500002,
+              50.62507306341437
             ],
             [
               -1.9445800781249998,
@@ -577,17 +468,13 @@
               -0.3515625,
               49.69606181911566
             ],
-            [
-              0.87890625,
-              50.736455137010665
-            ],
             [
               2.5048828125,
               51.6180165487737
             ],
             [
-              2.63671875,
-              52.119998657638156
+              1.9116210937499998,
+              61.19621314083867
             ]
           ]
         ]
@@ -602,10 +489,6 @@
         "type": "Polygon",
         "coordinates": [
           [
-            [
-              91.77978515625,
-              20.899871347076424
-            ],
             [
               92.39501953125,
               21.514406720030294
@@ -950,10 +833,6 @@
               61.58935546875,
               25.224820176765036
             ],
-            [
-              67.8076171875,
-              16.678293098288513
-            ],
             [
               74.970703125,
               7.580327791330129
@@ -967,16 +846,12 @@
               -2.986927393334863
             ],
             [
-              84.8583984375,
-              0.4833927027896987
+              85.86914062500001,
+              5.5941182188847876
             ],
             [
-              88.3740234375,
-              14.774882506516272
-            ],
-            [
-              91.77978515625,
-              20.899871347076424
+              92.39501953125,
+              21.514406720030294
             ]
           ]
         ]
@@ -985,23 +860,15 @@
     {
       "type": "Feature",
       "properties": {
-        "stroke": "#555555",
-        "stroke-width": 2,
-        "stroke-opacity": 1,
-        "fill": "#555555",
-        "fill-opacity": 0.5
+        "driving_side": "left"
       },
       "geometry": {
         "type": "Polygon",
         "coordinates": [
           [
             [
-              43.41796875,
-              -3.1405161039832357
-            ],
-            [
-              41.6162109375,
-              -1.7355743631421197
+              43.57177734375001,
+              -4.390228926463384
             ],
             [
               41.0009765625,
@@ -1264,20 +1131,8 @@
               -34.74161249883172
             ],
             [
-              40.95703125,
-              -18.646245142670598
-            ],
-            [
-              42.2314453125,
-              -13.581920900545844
-            ],
-            [
-              41.3525390625,
-              -8.754794702435618
-            ],
-            [
-              43.41796875,
-              -3.1405161039832357
+              43.57177734375001,
+              -4.390228926463384
             ]
           ]
         ]
@@ -1718,24 +1573,24 @@
         "coordinates": [
           [
             [
-              -82.012939453125,
-              18.90108960836388
+              -81.67236328125001,
+              19.03875247795316
             ],
             [
-              -80.48583984375,
-              18.90108960836388
+              -79.76898193359376,
+              19.48989674307901
             ],
             [
-              -80.48583984375,
-              19.735683578629445
+              -79.48333740234375,
+              19.888140273126222
             ],
             [
-              -82.012939453125,
-              19.735683578629445
+              -81.45263671875001,
+              19.46400263520258
             ],
             [
-              -82.012939453125,
-              18.90108960836388
+              -81.67236328125001,
+              19.03875247795316
             ]
           ]
         ]
@@ -1979,6 +1834,387 @@
           ]
         ]
       }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "driving_side": "left"
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -79.82666015625001,
+              25.035838555635017
+            ],
+            [
+              -73.55346679687501,
+              20.324023603422518
+            ],
+            [
+              -70.82336425781251,
+              21.307287323905406
+            ],
+            [
+              -78.38745117187501,
+              28.304380682962783
+            ],
+            [
+              -79.82666015625001,
+              25.035838555635017
+            ]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "driving_side": "left"
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -59.06250000000001,
+              13.378931658431565
+            ],
+            [
+              -61.02905273437501,
+              14.216463756160174
+            ],
+            [
+              -61.92443847656251,
+              12.350734120814016
+            ],
+            [
+              -61.71569824218751,
+              10.935798432254105
+            ],
+            [
+              -62.06176757812501,
+              10.028357677443571
+            ],
+            [
+              -61.13891601562501,
+              9.855216086088848
+            ],
+            [
+              -59.06250000000001,
+              13.378931658431565
+            ]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "driving_side": "left"
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -61.43829345703126,
+              17.17228278169308
+            ],
+            [
+              -61.80358886718751,
+              17.882045302279195
+            ],
+            [
+              -62.91870117187501,
+              17.403062993328938
+            ],
+            [
+              -62.149658203125,
+              16.52826534972986
+            ],
+            [
+              -61.43829345703126,
+              17.17228278169308
+            ]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "driving_side": "left"
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -61.33392333984376,
+              15.731457491108594
+            ],
+            [
+              -61.63604736328126,
+              15.570127852659427
+            ],
+            [
+              -61.36138916015626,
+              15.10394633500913
+            ],
+            [
+              -61.13342285156251,
+              15.257689080778713
+            ],
+            [
+              -61.33392333984376,
+              15.731457491108594
+            ]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "driving_side": "left"
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -63.46664428710938,
+              18.672267305093758
+            ],
+            [
+              -64.5604705810547,
+              18.78736737706614
+            ],
+            [
+              -64.8845672607422,
+              18.40665471391907
+            ],
+            [
+              -64.6593475341797,
+              18.365604299215338
+            ],
+            [
+              -64.61608886718751,
+              18.114529138838503
+            ],
+            [
+              -63.30596923828126,
+              18.108002884854656
+            ],
+            [
+              -62.79235839843751,
+              18.231960055191504
+            ],
+            [
+              -63.46664428710938,
+              18.672267305093758
+            ]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "driving_side": "left"
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              31.898803710937504,
+              35.29943548054545
+            ],
+            [
+              32.38220214843751,
+              34.43409789359469
+            ],
+            [
+              34.69482421875001,
+              34.74161249883172
+            ],
+            [
+              34.74975585937501,
+              35.79999392988527
+            ],
+            [
+              31.898803710937504,
+              35.29943548054545
+            ]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "driving_side": "left"
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              166.53076171875003,
+              -0.7140928403610857
+            ],
+            [
+              172.81494140625009,
+              0.4751532449748611
+            ],
+            [
+              176.50634765625003,
+              -17.245744208007117
+            ],
+            [
+              177.82470703125009,
+              -19.36038488536514
+            ],
+            [
+              180.0439453125002,
+              -19.67103928897615
+            ],
+            [
+              180.1098632812502,
+              -13.333502655583224
+            ],
+            [
+              189.00878906250003,
+              -9.760490714194388
+            ],
+            [
+              189.931640625,
+              -4.726989319952657
+            ],
+            [
+              199.62158203125003,
+              2.583657640731887
+            ],
+            [
+              201.04980468750003,
+              -0.6014904163878395
+            ],
+            [
+              193.31542968750003,
+              -9.543874794137526
+            ],
+            [
+              193.42529296875003,
+              -14.95274576245613
+            ],
+            [
+              183.7353515625,
+              -14.846576365691352
+            ],
+            [
+              180.3295898437502,
+              -24.27450874986185
+            ],
+            [
+              203.46679687500003,
+              -22.662175307872086
+            ],
+            [
+              203.2470703125,
+              -13.247966096402816
+            ],
+            [
+              211.33300781250003,
+              -11.35887518924762
+            ],
+            [
+              200.65429687500003,
+              6.468151012664214
+            ],
+            [
+              179.8461914062502,
+              -4.836470204221701
+            ],
+            [
+              173.1445312500001,
+              4.162897490667403
+            ],
+            [
+              166.53076171875003,
+              -0.7140928403610857
+            ]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "driving_side": "left"
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -127.33154296875001,
+              -24.166802085303225
+            ],
+            [
+              -131.17675781250003,
+              -23.60426184707018
+            ],
+            [
+              -130.34179687500003,
+              -25.324166525738384
+            ],
+            [
+              -123.49731445312501,
+              -24.716895455859337
+            ],
+            [
+              -127.33154296875001,
+              -24.166802085303225
+            ]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "driving_side": "left"
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -5.976562500000001,
+              -15.728813770533979
+            ],
+            [
+              -5.949096679687501,
+              -16.13026201203474
+            ],
+            [
+              -5.482177734375001,
+              -16.156644815257152
+            ],
+            [
+              -5.465698242187501,
+              -15.760536148501288
+            ],
+            [
+              -5.976562500000001,
+              -15.728813770533979
+            ]
+          ]
+        ]
+      }
     }
   ]
 }

docs/http.md

@@ -120,6 +120,7 @@ In addition to the [general options](#general-options) the following options are
 - `code` if the request was successful `Ok` otherwise see the service dependent and general status codes.
 - `waypoints` array of `Waypoint` objects sorted by distance to the input coordinate. Each object has at least the following additional properties:
   - `distance`: Distance in meters to the supplied input coordinate.
+  - `nodes`: Array of OpenStreetMap node ids.
 
 #### Example Requests
 
@@ -134,6 +135,10 @@ curl 'http://router.project-osrm.org/nearest/v1/driving/13.388860,52.517037?numb
 {
    "waypoints" : [
       {
+         "nodes": [
+            2264199819,
+            0
+         ],
          "hint" : "KSoKADRYroqUBAEAEAAAABkAAAAGAAAAAAAAABhnCQCLtwAA_0vMAKlYIQM8TMwArVghAwEAAQH1a66g",
          "distance" : 4.152629,
          "name" : "Friedrichstraße",
@@ -143,6 +148,10 @@ curl 'http://router.project-osrm.org/nearest/v1/driving/13.388860,52.517037?numb
          ]
       },
       {
+         "nodes": [
+            2045820592,
+            0
+         ],
          "hint" : "KSoKADRYroqUBAEABgAAAAAAAAAAAAAAKQAAABhnCQCLtwAA7kvMAAxZIQM8TMwArVghAwAAAQH1a66g",
          "distance" : 11.811961,
          "name" : "Friedrichstraße",
@@ -152,6 +161,10 @@ curl 'http://router.project-osrm.org/nearest/v1/driving/13.388860,52.517037?numb
          ]
       },
       {
+         "nodes": [
+            0,
+            21487242
+         ],
          "hint" : "KioKgDbbDgCUBAEAAAAAABoAAAAAAAAAPAAAABlnCQCLtwAA50vMADJZIQM8TMwArVghAwAAAQH1a66g",
          "distance" : 15.872438,
          "name" : "Friedrichstraße",
@@ -209,13 +222,13 @@ curl 'http://router.project-osrm.org/route/v1/driving/13.388860,52.517037;13.397
 
 ### Table service
 
-Computes the duration of the fastest route between all pairs of supplied coordinates.
+Computes the duration of the fastest route between all pairs of supplied coordinates. Returns the durations or distances or both between the coordinate pairs. Note that the distances are not the shortest distance between two coordinates, but rather the distances of the fastest routes. Duration is in seconds and distances is in meters.
 
 ```endpoint
-GET /table/v1/{profile}/{coordinates}?{sources}=[{elem}...];&destinations=[{elem}...]
+GET /table/v1/{profile}/{coordinates}?{sources}=[{elem}...];&{destinations}=[{elem}...]&annotations={duration|distance|duration,distance}
 ```
 
-**Coordinates**
+**Options**
 
 In addition to the [general options](#general-options) the following options are supported for this service:
 
@@ -223,6 +236,8 @@ In addition to the [general options](#general-options) the following options are
 |------------|--------------------------------------------------|---------------------------------------------|
 |sources     |`{index};{index}[;{index} ...]` or `all` (default)|Use location with given index as source.     |
 |destinations|`{index};{index}[;{index} ...]` or `all` (default)|Use location with given index as destination.|
+|annotations |`duration` (default), `distance`, or `duration,distance`|Return the requested table or tables in response. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
+|
 
 Unlike other array encoded options, the length of `sources` and `destinations` can be **smaller or equal**
 to number of input locations;
@@ -240,14 +255,23 @@ sources=0;5;7&destinations=5;1;4;2;3;6
 #### Example Request
 
 ```curl
-# Returns a 3x3 matrix:
+# Returns a 3x3 duration matrix:
 curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397634,52.529407;13.428555,52.523219'
 
-# Returns a 1x3 matrix
+# Returns a 1x3 duration matrix
 curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397634,52.529407;13.428555,52.523219?sources=0'
 
-# Returns a asymmetric 3x2 matrix with from the polyline encoded locations `qikdcB}~dpXkkHz`:
+# Returns a asymmetric 3x2 duration matrix with from the polyline encoded locations `qikdcB}~dpXkkHz`:
 curl 'http://router.project-osrm.org/table/v1/driving/polyline(egs_Iq_aqAppHzbHulFzeMe`EuvKpnCglA)?sources=0;1;3&destinations=2;4'
+
+# Returns a 3x3 duration matrix:
+curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397634,52.529407;13.428555,52.523219?annotations=duration'
+
+# Returns a 3x3 distance matrix for CH:
+curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397634,52.529407;13.428555,52.523219?annotations=distance'
+
+# Returns a 3x3 duration matrix and a 3x3 distance matrix for CH:
+curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397634,52.529407;13.428555,52.523219?annotations=distance,duration'
 ```
 
 **Response**
@@ -255,17 +279,115 @@ curl 'http://router.project-osrm.org/table/v1/driving/polyline(egs_Iq_aqAppHzbHu
 - `code` if the request was successful `Ok` otherwise see the service dependent and general status codes.
 - `durations` array of arrays that stores the matrix in row-major order. `durations[i][j]` gives the travel time from
   the i-th waypoint to the j-th waypoint. Values are given in seconds. Can be `null` if no route between `i` and `j` can be found.
+- `distances` array of arrays that stores the matrix in row-major order. `distances[i][j]` gives the travel distance from
+  the i-th waypoint to the j-th waypoint. Values are given in meters. Can be `null` if no route between `i` and `j` can be found. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
 - `sources` array of `Waypoint` objects describing all sources in order
 - `destinations` array of `Waypoint` objects describing all destinations in order
 
 In case of error the following `code`s are supported in addition to the general ones:
 
-| Type              | Description     |
-|-------------------|-----------------|
+| Type             | Description     |
+|------------------|-----------------|
 | `NoTable`        | No route found. |
+| `NotImplemented`  | This request is not supported |
 
 All other properties might be undefined.
 
+#### Example Response
+
+```json
+{
+  "sources": [
+    {
+      "location": [
+        13.3888,
+        52.517033
+      ],
+      "hint": "PAMAgEVJAoAUAAAAIAAAAAcAAAAAAAAArss0Qa7LNEHiVIRA4lSEQAoAAAAQAAAABAAAAAAAAADMAAAAAEzMAKlYIQM8TMwArVghAwEA3wps52D3",
+      "name": "Friedrichstraße"
+    },
+    {
+      "location": [
+        13.397631,
+        52.529432
+      ],
+      "hint": "WIQBgL6mAoAEAAAABgAAAAAAAAA7AAAAhU6PQHvHj0IAAAAAQbyYQgQAAAAGAAAAAAAAADsAAADMAAAAf27MABiJIQOCbswA_4ghAwAAXwVs52D3",
+      "name": "Torstraße"
+    },
+    {
+      "location": [
+        13.428554,
+        52.523239
+      ],
+      "hint": "7UcAgP___38fAAAAUQAAACYAAABTAAAAhSQKQrXq5kKRbiZCWJo_Qx8AAABRAAAAJgAAAFMAAADMAAAASufMAOdwIQNL58wA03AhAwMAvxBs52D3",
+      "name": "Platz der Vereinten Nationen"
+    }
+  ],
+  "durations": [
+    [
+      0,
+      192.6,
+      382.8
+    ],
+    [
+      199,
+      0,
+      283.9
+    ],
+    [
+      344.7,
+      222.3,
+      0
+    ]
+  ],
+  "destinations": [
+    {
+      "location": [
+        13.3888,
+        52.517033
+      ],
+      "hint": "PAMAgEVJAoAUAAAAIAAAAAcAAAAAAAAArss0Qa7LNEHiVIRA4lSEQAoAAAAQAAAABAAAAAAAAADMAAAAAEzMAKlYIQM8TMwArVghAwEA3wps52D3",
+      "name": "Friedrichstraße"
+    },
+    {
+      "location": [
+        13.397631,
+        52.529432
+      ],
+      "hint": "WIQBgL6mAoAEAAAABgAAAAAAAAA7AAAAhU6PQHvHj0IAAAAAQbyYQgQAAAAGAAAAAAAAADsAAADMAAAAf27MABiJIQOCbswA_4ghAwAAXwVs52D3",
+      "name": "Torstraße"
+    },
+    {
+      "location": [
+        13.428554,
+        52.523239
+      ],
+      "hint": "7UcAgP___38fAAAAUQAAACYAAABTAAAAhSQKQrXq5kKRbiZCWJo_Qx8AAABRAAAAJgAAAFMAAADMAAAASufMAOdwIQNL58wA03AhAwMAvxBs52D3",
+      "name": "Platz der Vereinten Nationen"
+    }
+  ],
+  "code": "Ok",
+  "distances": [
+    [
+      0,
+      1886.89,
+      3791.3
+    ],
+    [
+      1824,
+      0,
+      2838.09
+    ],
+    [
+      3275.36,
+      2361.73,
+      0
+    ]
+  ]
+}
+```
+
+
 ### Match service
 
 Map matching matches/snaps given GPS points to the road network in the most plausible way.
@@ -515,10 +637,10 @@ Represents a route between two waypoints.
 
 - `annotation`: Additional details about each coordinate along the route geometry:
 
-| annotations  |                                                                       |
-|--------------|-----------------------------------------------------------------------|
-| true         | An `Annotation` object containing node ids, durations distances and   |
-| false        | weights `undefined`                                                   |
+| annotations  |                                                                               |
+|--------------|-------------------------------------------------------------------------------|
+| true         | An `Annotation` object containing node ids, durations, distances and weights. |
+| false        | `undefined`                                                                   |
 
 #### Example
 
@@ -534,6 +656,7 @@ With `steps=false` and `annotations=true`:
     "distance": [5,5,10,5,5],
     "duration": [15,15,40,15,15],
     "datasources": [1,0,0,0,1],
+    "metadata": { "datasource_names": ["traffic","lua profile","lua profile","lua profile","traffic"] },
     "nodes": [49772551,49772552,49786799,49786800,49786801,49786802],
     "speed": [0.3, 0.3, 0.3, 0.3, 0.3]
   }
@@ -548,10 +671,12 @@ Annotation of the whole route leg with fine-grained information about each segme
 
 - `distance`: The distance, in metres, between each pair of coordinates
 - `duration`: The duration between each pair of coordinates, in seconds.  Does not include the duration of any turns.
-- `datasources`: The index of the datasource for the speed between each pair of coordinates. `0` is the default profile, other values are supplied via `--segment-speed-file` to `osrm-contract`
+- `datasources`: The index of the datasource for the speed between each pair of coordinates. `0` is the default profile, other values are supplied via `--segment-speed-file` to `osrm-contract` or `osrm-customize`.  String-like names are in the `metadata.datasource_names` array.
 - `nodes`: The OSM node ID for each coordinate along the route, excluding the first/last user-supplied coordinates
 - `weight`: The weights between each pair of coordinates.  Does not include any turn costs.
 - `speed`: Convenience field, calculation of `distance / duration` rounded to one decimal place
+- `metadata`: Metadata related to other annotations
+  - `datasource_names`: The names of the datasources used for the speed between each pair of coordinates.  `lua profile` is the default profile, other values arethe filenames supplied via `--segment-speed-file` to `osrm-contract` or `osrm-customize`
 
 #### Example
 
@@ -560,6 +685,7 @@ Annotation of the whole route leg with fine-grained information about each segme
   "distance": [5,5,10,5,5],
   "duration": [15,15,40,15,15],
   "datasources": [1,0,0,0,1],
+  "metadata": { "datasource_names": ["traffic","lua profile","lua profile","lua profile","traffic"] },
   "nodes": [49772551,49772552,49786799,49786800,49786801,49786802],
   "weight": [15,15,40,15,15]
 }

docs/nodejs/api.md

@@ -25,6 +25,7 @@ var osrm = new OSRM('network.osrm');
                Make sure you prepared the dataset with the correct toolchain.
     -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
                This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
+    -   `options.memory_file` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Path to a file on disk to store the memory using mmap.
     -   `options.path` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** The path to the `.osrm` files. This is mutually exclusive with setting {options.shared_memory} to true.
     -   `options.max_locations_trip` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in trip query (default: unlimited).
     -   `options.max_locations_viaroute` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in viaroute query (default: unlimited).
@@ -61,7 +62,7 @@ Returns the fastest route between two or more coordinates while visiting the way
 
 ```javascript
 var osrm = new OSRM("berlin-latest.osrm");
-osrm.route({coordinates: [[52.519930,13.438640], [52.513191,13.415852]]}, function(err, result) {
+osrm.route({coordinates: [[13.438640,52.519930], [13.415852,52.513191]]}, function(err, result) {
   if(err) throw err;
   console.log(result.waypoints); // array of Waypoint objects representing all waypoints in order
   console.log(result.routes); // array of Route objects ordered by descending recommendation rank
@@ -109,8 +110,8 @@ Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refer
 
 ### table
 
-Computes duration tables for the given locations. Allows for both symmetric and asymmetric
-tables.
+Computes duration table for the given locations. Allows for both symmetric and asymmetric
+tables. Optionally returns distance table.
 
 **Parameters**
 

docs/profiles.md

@@ -68,7 +68,7 @@ If you want to prioritize certain streets, increase the rate on these.
 
 ## Elements
 ### api_version
-A profile should set `api_version` at the top of your profile. This is done to ensure that older profiles are still supported when the api changes. If `api_version` is not defined, 0 will be assumed. The current api version is 2.
+A profile should set `api_version` at the top of your profile. This is done to ensure that older profiles are still supported when the api changes. If `api_version` is not defined, 0 will be assumed. The current api version is 4.
 
 ### Library files
 The folder [profiles/lib/](../profiles/lib/) contains LUA library files for handling many common processing tasks.
@@ -138,7 +138,7 @@ Given an OpenStreetMap way, the `process_way` function will either return nothin
 Argument | Description
 ---------|-------------------------------------------------------
 profile  | The configuration table you returned in `setup`.
-node     | The input way to process (read-only).
+way      | The input way to process (read-only).
 result   | The output that you will modify.
 relations| Storage of relations to access relations, where `way` is a member.
 
@@ -199,7 +199,7 @@ source.lon         | Read        | Float   | Co-ordinates of segment start
 source.lat         | Read        | Float   |  ""
 target.lon         | Read        | Float   | Co-ordinates of segment end
 target.lat         | Read        | Float   |  ""
-target.distance    | Read        | Float   | Length of segment
+distance           | Read        | Float   | Length of segment
 weight             | Read/write  | Float   | Routing weight for this segment
 duration           | Read/write  | Float   | Duration for this segment
 
@@ -208,19 +208,103 @@ The `process_turn` function is called for every possible turn in the network. Ba
 
 The following attributes can be read and set on the result in `process_turn`:
 
-Attribute            | Read/write? | Type    | Notes
----------------------|-------------|---------|------------------------------------------------------
-angle                | Read        | Float   | Angle of turn in degrees (`0-360`: `0`=u-turn, `180`=straight on)
-number_of_roads      | Read        | Integer | Number of ways at the intersection of the turn
-is_u_turn            | Read        | Boolean | Is the turn a u-turn?
-has_traffic_light    | Read        | Boolean | Is a traffic light present at this turn?
-source_restricted    | Read        | Boolean | Is it from a restricted access road? (See definition in `process_way`)
-target_restricted    | Read        | Boolean | Is it to a restricted access road? (See definition in `process_way`)
-is_left_hand_driving | Read        | Boolean | Is left-hand traffic? 
-weight               | Read/write  | Float   | Penalty to be applied for this turn (routing weight)
-duration             | Read/write  | Float   | Penalty to be applied for this turn (duration in deciseconds)
-source_mode          | Read        | Enum    | Travel mode before the turn. Defined in `include/extractor/travel_mode.hpp`
-target_mode          | Read        | Enum    | Travel mode after the turn. Defined in `include/extractor/travel_mode.hpp`
+Attribute                          | Read/write?   | Type                      | Notes
+---------------------              | ------------- | ---------                 | ------------------------------------------------------
+angle                              | Read          | Float                     | Angle of turn in degrees (`[-179, 180]`: `0`=straight, `180`=u turn, `+x`=x degrees to the right, `-x`= x degrees to the left)
+number_of_roads                    | Read          | Integer                   | Number of ways at the intersection of the turn
+is_u_turn                          | Read          | Boolean                   | Is the turn a u-turn?
+has_traffic_light                  | Read          | Boolean                   | Is a traffic light present at this turn?
+is_left_hand_driving               | Read          | Boolean                   | Is left-hand traffic?
+source_restricted                  | Read          | Boolean                   | Is it from a restricted access road? (See definition in `process_way`)
+source_mode                        | Read          | Enum                      | Travel mode before the turn. Defined in `include/extractor/travel_mode.hpp`
+source_is_motorway                 | Read          | Boolean                   | Is the source road a motorway?
+source_is_link                     | Read          | Boolean                   | Is the source road a link?
+source_number_of_lanes             | Read          | Integer                   | How many lanes does the source road have? (default when not tagged: 0)
+source_highway_turn_classification | Read          | Integer                   | Classification based on highway tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15))
+source_access_turn_classification  | Read          | Integer                   | Classification based on access tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15))
+source_speed                       | Read          | Integer                   | Speed on this source road in km/h
+source_priority_class              | Read          | Enum                      | The type of road priority class of the source. Defined in `include/extractor/guidance/road_classification.hpp`
+target_restricted                  | Read          | Boolean                   | Is the target a restricted access road? (See definition in `process_way`)
+target_mode                        | Read          | Enum                      | Travel mode after the turn. Defined in `include/extractor/travel_mode.hpp`
+target_is_motorway                 | Read          | Boolean                   | Is the target road a motorway?
+target_is_link                     | Read          | Boolean                   | Is the target road a link?
+target_number_of_lanes             | Read          | Integer                   | How many lanes does the target road have? (default when not tagged: 0)
+target_highway_turn_classification | Read          | Integer                   | Classification based on highway tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15))
+target_access_turn_classification  | Read          | Integer                   | Classification based on access tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15))
+target_speed                       | Read          | Integer                   | Speed on this target road in km/h
+target_priority_class              | Read          | Enum                      | The type of road priority class of the target. Defined in `include/extractor/guidance/road_classification.hpp`
+roads_on_the_right                 | Read          | Vector<ExtractionTurnLeg> | Vector with information about other roads on the right of the turn that are also connected at the intersection
+roads_on_the_left                  | Read          | Vector<ExtractionTurnLeg> | Vector with information about other roads on the left of the turn that are also connected at the intersection. If turn is a u turn, this is empty.
+weight                             | Read/write    | Float                     | Penalty to be applied for this turn (routing weight)
+duration                           | Read/write    | Float                     | Penalty to be applied for this turn (duration in deciseconds)
+
+#### `roads_on_the_right` and `roads_on_the_left`
+
+The information of `roads_on_the_right` and `roads_on_the_left` that can be read are as follows:
+
+Attribute                   | Read/write?   | Type      | Notes
+---------------------       | ------------- | --------- | ------------------------------------------------------
+is_restricted               | Read          | Boolean   | Is it a restricted access road? (See definition in `process_way`)
+mode                        | Read          | Enum      | Travel mode before the turn. Defined in `include/extractor/travel_mode.hpp`
+is_motorway                 | Read          | Boolean   | Is the road a motorway?
+is_link                     | Read          | Boolean   | Is the road a link?
+number_of_lanes             | Read          | Integer   | How many lanes does the road have? (default when not tagged: 0)
+highway_turn_classification | Read          | Integer   | Classification based on highway tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15)
+access_turn_classification  | Read          | Integer   | Classification based on access tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15)
+speed                       | Read          | Integer   | Speed on this road in km/h
+priority_class              | Read          | Enum      | The type of road priority class of the leg. Defined in `include/extractor/guidance/road_classification.hpp`
+is_incoming                 | Read          | Boolean   | Is the road an incoming road of the intersection
+is_outgoing                 | Read          | Boolean   | Is the road an outgoing road of the intersection
+
+The order of the roads in `roads_on_the_right` and `roads_on_the_left` are *counter clockwise*. If the turn is a u turn, all other connected roads will be in `roads_on_the_right`.
+
+**Example**
+
+```
+           c   e
+           |  /
+           | /
+    a ---- x ---- b
+          /|
+         / |
+        f  d
+
+
+```
+When turning from `a` to `b` via `x`,
+* `roads_on_the_right[1]` is the road `xf`
+* `roads_on_the_right[2]` is the road `xd`
+* `roads_on_the_left[1]` is the road `xe`
+* `roads_on_the_left[2]` is the road `xc`
+
+Note that indices of arrays in lua are 1-based.
+
+#### `highway_turn_classification` and `access_turn_classification`
+When setting appropriate turn weights and duration, information about the highway and access tags of roads that are involved in the turn are necessary. The lua turn function `process_turn` does not have access to the original osrm tags anymore. However, `highway_turn_classification` and `access_turn_classification` can be set during setup. The classification set during setup can be later used in `process_turn`.
+
+**Example**
+
+In the following example we use `highway_turn_classification` to set the turn weight to `10` if the turn is on a highway and to `5` if the turn is on a primary.
+
+```
+function setup()
+  return {
+    highway_turn_classification = {
+      ['motorway'] = 2,
+      ['primary'] = 1
+    }
+  }
+end
+
+function process_turn(profile, turn) {
+  if turn.source_highway_turn_classification == 2 and turn.target_highway_turn_classification == 2 then
+    turn.weight = 10
+  end
+  if turn.source_highway_turn_classification == 1 and turn.target_highway_turn_classification == 1 then
+    turn.weight = 5
+  end
+}
+```
 
 ## Guidance
 The guidance parameters in profiles are currently a work in progress. They can and will change.

docs/releasing.md

@@ -43,12 +43,14 @@ We may introduce forward-compatible changes: query parameters and response prope
 
 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 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`
+3. Make sure the `package.json` on branch `x.y` has been committed.
+4. Make sure all tests are passing (e.g. Travis CI gives you a :green_apple:)
+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. Commit should be one in which the `package.json` version matches the version you want to release.
+6. Use `npm run 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
+7. Push tags and commits: `git push; git push --tags`
+8. On https://github.com/Project-OSRM/osrm-backend/releases press `Draft a new release`,
+   write the release tag `vx.y.z` in the `Tag version` field, write the changelog entries in the `Describe this release` field
+   and press `Publish release`.
 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.

features/bicycle/barrier.feature

@@ -19,7 +19,7 @@ Feature: Barriers
             | entrance       | x     |
             | wall           |       |
             | fence          |       |
-            | some_tag       |       |
+            | some_tag       | x     |
             | block          | x     |
 
     Scenario: Bike - Access tag trumphs barriers

features/bicycle/classes.feature

@@ -0,0 +1,92 @@
+@routing @bicycle @mode
+Feature: Bicycle - Mode flag
+    Background:
+        Given the profile "bicycle"
+
+    Scenario: Bicycle - We tag ferries with a class
+        Given the node map
+            """
+            a b
+              c d
+            """
+
+        And the ways
+            | nodes | highway | route |
+            | ab    | primary |       |
+            | bc    |         | ferry |
+            | cd    | primary |       |
+
+        When I route I should get
+            | from | to | route       | turns                                              | classes                  |
+            | a    | d  | ab,bc,cd,cd | depart,notification right,notification left,arrive | [()],[(ferry)],[()],[()] |
+            | d    | a  | cd,bc,ab,ab | depart,notification right,notification left,arrive | [()],[(ferry)],[()],[()] |
+            | c    | a  | bc,ab,ab    | depart,notification left,arrive                    | [(ferry)],[()],[()]      |
+            | d    | b  | cd,bc,bc    | depart,notification right,arrive                   | [()],[(ferry)],[()]      |
+            | a    | c  | ab,bc,bc    | depart,notification right,arrive                   | [()],[(ferry)],[()]      |
+            | b    | d  | bc,cd,cd    | depart,notification left,arrive                    | [(ferry)],[()],[()]      |
+
+    Scenario: Bicycle - We tag tunnel with a class
+        Background:
+            Given a grid size of 200 meters
+
+        Given the node map
+            """
+            a b
+              c d
+            """
+
+        And the ways
+            | nodes | tunnel               |
+            | ab    | no                   |
+            | bc    | yes                  |
+            | cd    |                      |
+
+        When I route I should get
+            | from | to | route       | turns                                      | classes                   |
+            | a    | d  | ab,bc,cd,cd | depart,new name right,new name left,arrive | [()],[(tunnel)],[()],[()] |
+
+    Scenario: Bicycle - We tag classes without intersections
+        Background:
+            Given a grid size of 200 meters
+
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes | name | tunnel |
+            | ab    | road |        |
+            | bc    | road | yes    |
+            | cd    | road |        |
+
+        When I route I should get
+          | from | to | route     | turns         | classes               |
+          | a    | d  | road,road | depart,arrive | [(),(tunnel),()],[()] |
+
+    Scenario: Bicycle - From roundabout on ferry
+        Given the node map
+            """
+                     c
+                  /     \
+            a---b         d---f--h
+                  \     /
+                     e
+                     |
+                     g
+            """
+
+        And the ways
+            | nodes | oneway | highway | junction   | route    |
+            | ab    | yes    | service |            |          |
+            | cb    | yes    | service | roundabout |          |
+            | dc    | yes    | service | roundabout |          |
+            | be    | yes    | service | roundabout |          |
+            | ed    | yes    | service | roundabout |          |
+            | eg    | yes    | service |            |          |
+            | df    |        |         |            | ferry    |
+            | fh    | yes    | service |            |          |
+
+        When I route I should get
+            | from | to | route          | turns                                                                              | classes                          |
+            | a    | h  | ab,df,df,fh,fh | depart,roundabout-exit-2,exit roundabout slight right,notification straight,arrive | [()],[(),()],[(ferry)],[()],[()] |

features/bicycle/cycleway.feature

@@ -46,12 +46,14 @@ Feature: Bike - Cycle tracks/lanes
             | primary  |          |               |                | x    | x     |
             | motorway |          |               |                |      |       |
             | motorway | track    |               |                | x    |       |
-            | motorway | opposite |               |                |      | x     |
-            | motorway |          | track         |                |      | x     |
-            | motorway |          | opposite      |                |      | x     |
+            | motorway | opposite |               |                | x    | x     |
+            | motorway |          | track         |                | x    |       |
+            | motorway |          | opposite      |                | x    | x     |
             | motorway |          |               | track          | x    |       |
-            | motorway |          |               | opposite       | x    |       |
-            | motorway |          | track         | track          | x    | x     |
+            | motorway |          |               | opposite       | x    | x     |
+            # motorways are implicit oneways and cycleway tracks next to oneways always
+            # follow the oneway direction (unless tagged as opposite)
+            | motorway |          | track         | track          | x    |       |
             | motorway |          | opposite      | opposite       | x    | x     |
             | motorway |          | track         | opposite       | x    | x     |
             | motorway |          | opposite      | track          | x    | x     |
@@ -92,6 +94,6 @@ Feature: Bike - Cycle tracks/lanes
         Then routability should be
             | highway     | cycleway | oneway | forw    | backw      |
             | motorway    | track    | yes    | 15 km/h |            |
-            | residential | track    | yes    | 15 km/h | 6 km/h +-1 |
-            | cycleway    | track    | yes    | 15 km/h | 6 km/h +-1 |
-            | footway     | track    | yes    | 15 km/h | 6 km/h +-1 |
+            | residential | track    | yes    | 15 km/h | 4 km/h +-1 |
+            | cycleway    | track    | yes    | 15 km/h | 4 km/h +-1 |
+            | footway     | track    | yes    | 15 km/h | 4 km/h +-1 |

features/bicycle/exclude.feature

@@ -0,0 +1,55 @@
+@routing @bicycle @exclude
+Feature: Bicycle - Exclude flags
+    Background:
+        Given the profile file "bicycle" initialized with
+        """
+        profile.excludable = Sequence { Set { 'ferry' } }
+        """
+        Given the node map
+            """
+            a....b~~~~~c...f
+                 :     :
+                 d.....e
+            """
+
+        And the ways
+            | nodes | highway  | route | duration | #                                           |
+            | ab    | service  |       |          | always drivable                             |
+            | bc    |          | ferry | 00:00:01 | not drivable for exclude=ferry, but fast.   |
+            | bd    | service  |       |          | always drivable                             |
+            | de    | service  |       |          | always drivable                             |
+            | ec    | service  |       |          | always drivable                             |
+            | cf    | service  |       |          | always drivable                             |
+
+    Scenario: Bicycle - exclude nothing
+        When I route I should get
+            | from | to | route          |
+            | a    | f  | ab,bc,cf,cf    |
+
+        When I match I should get
+            | trace | matchings | duration |
+            | abcf  | abcf      | 109      |
+
+        When I request a travel time matrix I should get
+            |   | a   | f   |
+            | a | 0   | 109 |
+            | f | 109 | 0   |
+
+    Scenario: Bicycle - exclude ferry
+        Given the query options
+            | exclude  | ferry        |
+
+        When I route I should get
+            | from | to | route             |
+            | a    | f  | ab,bd,de,ec,cf,cf |
+
+        When I match I should get
+            | trace | matchings | duration |
+            | abcf  | abcf      | 301.2    |
+
+        When I request a travel time matrix I should get
+            |   | a          | f        |
+            | a | 0          | 301 +- 1 |
+            | f | 301.2 +- 1 | 0        |
+
+

features/bicycle/oneway.feature

@@ -141,5 +141,12 @@ Feature: Bike - Oneway streets
             | highway     | oneway | cycleway:left  | cycleway:right | forw    | backw        |
             | primary     | yes    |                |                | cycling | pushing bike |
             | primary     | yes    |                | track          | cycling | pushing bike |
-            | primary     | yes    | track          |                | cycling | cycling      |
-            | primary     | yes    | track          | track          | cycling | cycling      |
+            | primary     | yes    | track          |                | cycling | pushing bike |
+            | primary     | yes    | track          | track          | cycling | pushing bike |
+
+    Scenario: Bike - Left/right cycleways on any oneways
+        Then routability should be
+            | foot | oneway | cycleway:left | cycleway:right | forw         | backw        |
+            | no   | yes    | track         |                | cycling      |              |
+            | yes  | yes    | track         |                | cycling      | pushing bike |
+            | yes  | -1     | track         |                | pushing bike | cycling      |

features/bicycle/safety.feature

@@ -11,15 +11,15 @@ Feature: Bicycle - Adds penalties to unsafe roads
         Then routability should be
             | highway        | cycleway | forw       | backw      | forw_rate | backw_rate |
             | motorway       |          |            |            |           |            |
-            | primary        |          | 15 km/h    | 15 km/h    |       2.9 |        2.9 |
-            | secondary      |          | 15 km/h    | 15 km/h    |       3.1 |        3.1 |
+            | primary        |          | 15 km/h    | 15 km/h    |       2.1 |        2.1 |
+            | secondary      |          | 15 km/h    | 15 km/h    |       2.7 |        2.7 |
             | tertiary       |          | 15 km/h    | 15 km/h    |       3.3 |        3.3 |
-            | primary_link   |          | 15 km/h    | 15 km/h    |       2.9 |        2.9 |
-            | secondary_link |          | 15 km/h    | 15 km/h    |       3.1 |        3.1 |
+            | primary_link   |          | 15 km/h    | 15 km/h    |       2.1 |        2.1 |
+            | secondary_link |          | 15 km/h    | 15 km/h    |       2.7 |        2.7 |
             | tertiary_link  |          | 15 km/h    | 15 km/h    |       3.3 |        3.3 |
             | residential    |          | 15 km/h    | 15 km/h    |       4.2 |        4.2 |
             | cycleway       |          | 15 km/h    | 15 km/h    |       4.2 |        4.2 |
-            | footway        |          | 6 km/h +-1 | 6 km/h +-1 |       1.7 |        1.7 |
+            | footway        |          | 4 km/h +-1 | 4 km/h +-1 |       1.1 |        1.1 |
 
     Scenario: Bike - Apply no penalties to ways with cycleways
         Then routability should be
@@ -51,49 +51,49 @@ Feature: Bicycle - Adds penalties to unsafe roads
         Then routability should be
             | highway        | cycleway:right | cycleway:left | forw        | backw       | forw_rate | backw_rate |
             | motorway       | track          |               | 15 km/h     |             |       4.2 |            |
-            | primary        | track          |               | 15 km/h     | 15 km/h     |       4.2 |        2.9 |
-            | secondary      | track          |               | 15 km/h     | 15 km/h     |       4.2 |        3.1 |
+            | primary        | track          |               | 15 km/h     | 15 km/h     |       4.2 |        2.1 |
+            | secondary      | track          |               | 15 km/h     | 15 km/h     |       4.2 |        2.7 |
             | tertiary       | track          |               | 15 km/h     | 15 km/h     |       4.2 |        3.3 |
-            | primary_link   | track          |               | 15 km/h     | 15 km/h     |       4.2 |        2.9 |
-            | secondary_link | track          |               | 15 km/h     | 15 km/h     |       4.2 |        3.1 |
+            | primary_link   | track          |               | 15 km/h     | 15 km/h     |       4.2 |        2.1 |
+            | secondary_link | track          |               | 15 km/h     | 15 km/h     |       4.2 |        2.7 |
             | tertiary_link  | track          |               | 15 km/h     | 15 km/h     |       4.2 |        3.3 |
             | residential    | track          |               | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
             | cycleway       | track          |               | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
-            | footway        | track          |               | 15 km/h     | 6 km/h +-1  |       4.2 |        1.7 |
-            | motorway       |                | track         |             | 15 km/h     |           |        4.2 |
-            | primary        |                | track         | 15 km/h     | 15 km/h     |       2.9 |        4.2 |
-            | secondary      |                | track         | 15 km/h     | 15 km/h     |       3.1 |        4.2 |
+            | footway        | track          |               | 15 km/h     | 4 km/h +-1  |       4.2 |        1.1 |
+            | motorway       |                | track         | 15 km/h     |             |       4.2 |            |
+            | primary        |                | track         | 15 km/h     | 15 km/h     |       2.1 |        4.2 |
+            | secondary      |                | track         | 15 km/h     | 15 km/h     |       2.7 |        4.2 |
             | tertiary       |                | track         | 15 km/h     | 15 km/h     |       3.3 |        4.2 |
-            | primary_link   |                | track         | 15 km/h     | 15 km/h     |       2.9 |        4.2 |
-            | secondary_link |                | track         | 15 km/h     | 15 km/h     |       3.1 |        4.2 |
+            | primary_link   |                | track         | 15 km/h     | 15 km/h     |       2.1 |        4.2 |
+            | secondary_link |                | track         | 15 km/h     | 15 km/h     |       2.7 |        4.2 |
             | tertiary_link  |                | track         | 15 km/h     | 15 km/h     |       3.3 |        4.2 |
             | residential    |                | track         | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
             | cycleway       |                | track         | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
-            | footway        |                | track         | 6 km/h +-1  | 15 km/h     |       1.7 |        4.2 |
+            | footway        |                | track         | 4 km/h +-1  | 15 km/h     |       1.1 |        4.2 |
             | motorway       | lane           |               | 15 km/h     |             |       4.2 |            |
-            | primary        | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        2.9 |
-            | secondary      | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        3.1 |
+            | primary        | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        2.1 |
+            | secondary      | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        2.7 |
             | tertiary       | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        3.3 |
-            | primary_link   | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        2.9 |
-            | secondary_link | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        3.1 |
+            | primary_link   | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        2.1 |
+            | secondary_link | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        2.7 |
             | tertiary_link  | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        3.3 |
             | residential    | lane           |               | 15 km/h +-1 | 15 km/h +-1 |       4.2 |        4.2 |
             | cycleway       | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
-            | footway        | lane           |               | 15 km/h     | 6 km/h +-1  |       4.2 |        1.7 |
-            | motorway       |                | lane          |             | 15 km/h     |           |        4.2 |
-            | primary        |                | lane          | 15 km/h     | 15 km/h     |       2.9 |        4.2 |
-            | secondary      |                | lane          | 15 km/h +-1 | 15 km/h +-1 |       3.1 |        4.2 |
+            | footway        | lane           |               | 15 km/h     | 4 km/h +-1  |       4.2 |        1.1 |
+            | motorway       |                | lane          | 15 km/h     |             |       4.2 |            |
+            | primary        |                | lane          | 15 km/h     | 15 km/h     |       2.1 |        4.2 |
+            | secondary      |                | lane          | 15 km/h +-1 | 15 km/h +-1 |       2.7 |        4.2 |
             | tertiary       |                | lane          | 15 km/h     | 15 km/h     |       3.3 |        4.2 |
-            | primary_link   |                | lane          | 15 km/h     | 15 km/h     |       2.9 |        4.2 |
-            | secondary_link |                | lane          | 15 km/h     | 15 km/h     |       3.1 |        4.2 |
+            | primary_link   |                | lane          | 15 km/h     | 15 km/h     |       2.1 |        4.2 |
+            | secondary_link |                | lane          | 15 km/h     | 15 km/h     |       2.7 |        4.2 |
             | tertiary_link  |                | lane          | 15 km/h     | 15 km/h     |       3.3 |        4.2 |
             | residential    |                | lane          | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
             | cycleway       |                | lane          | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
-            | footway        |                | lane          | 6 km/h +-1  | 15 km/h     |       1.7 |        4.2 |
+            | footway        |                | lane          | 4 km/h +-1  | 15 km/h     |       1.1 |        4.2 |
             | motorway       | shared_lane    |               | 15 km/h     |             |       4.2 |            |
-            | primary        | shared_lane    |               | 15 km/h     | 15 km/h     |       4.2 |        2.9 |
-            | motorway       |                | shared_lane   |             | 15 km/h     |           |        4.2 |
-            | primary        |                | shared_lane   | 15 km/h     | 15 km/h     |       2.9 |        4.2 |
+            | primary        | shared_lane    |               | 15 km/h     | 15 km/h     |       4.2 |        2.1 |
+            | motorway       |                | shared_lane   | 15 km/h     |             |       4.2 |            |
+            | primary        |                | shared_lane   | 15 km/h     | 15 km/h     |       2.1 |        4.2 |
 
 
     Scenario: Bike - Don't apply penalties for all kind of cycleways
@@ -101,4 +101,4 @@ Feature: Bicycle - Adds penalties to unsafe roads
             | highway  | cycleway    | forw    | backw   | forw_rate | backw_rate |
             | tertiary | shared_lane | 15 km/h | 15 km/h |       4.2 |        4.2 |
             | tertiary | lane        | 15 km/h | 15 km/h |       4.2 |        4.2 |
-            | tertiary | opposite    | 15 km/h | 15 km/h |       3.3 |        4.2 |
+            | tertiary | opposite    | 15 km/h | 15 km/h |       3.3 |        3.3 |

features/bicycle/surface.feature

@@ -54,6 +54,6 @@ Feature: Bike - Surfaces
       When I route I should get
         | from | to | route | modes                     | speed   |
         | a    | b  | ab,ab | cycling,cycling           | 15 km/h |
-        | b    | a  | ab,ab | pushing bike,pushing bike | 6 km/h  |
-        | c    | d  | cd,cd | pushing bike,pushing bike | 6 km/h  |
-        | d    | c  | cd,cd | pushing bike,pushing bike | 6 km/h  |
+        | b    | a  | ab,ab | pushing bike,pushing bike | 4 km/h  |
+        | c    | d  | cd,cd | pushing bike,pushing bike | 4 km/h  |
+        | d    | c  | cd,cd | pushing bike,pushing bike | 4 km/h  |

features/car/barrier.feature

@@ -45,3 +45,11 @@ Feature: Car - Barriers
             | bollard      |               |       |
             | bollard      | rising        | x     |
             | bollard      | removable     |       |
+
+    Scenario: Car - Height restrictions
+        Then routability should be
+            | node/barrier      | node/maxheight | bothw |
+            | height_restrictor |                | x     |
+            | height_restrictor |              1 |       |
+            | height_restrictor |              3 | x     |
+            | height_restrictor |        default | x     |

features/car/classes.feature

@@ -82,7 +82,7 @@ Feature: Car - Mode flag
             | from | to | route | turns        | classes                                      |
             | a    | d  | ab,cd | depart,arrive| [(restricted),(motorway,restricted),()],[()] |
 
-    Scenario: Car - We toll restricted with a class
+    Scenario: Car - We tag toll with a class
         Given the node map
             """
             a b
@@ -99,6 +99,45 @@ Feature: Car - Mode flag
             | from | to | route    | turns         | classes                          |
             | a    | d  | ab,cd    | depart,arrive | [(toll),(motorway,toll),()],[()] |
 
+    Scenario: Car - We tag tunnel with a class
+        Background:
+            Given a grid size of 200 meters
+
+        Given the node map
+            """
+            a b
+              c d
+            """
+
+        And the ways
+            | nodes | tunnel               |
+            | ab    | no                   |
+            | bc    | yes                  |
+            | cd    |                      |
+
+        When I route I should get
+            | from | to | route       | turns                                      | classes                   |
+            | a    | d  | ab,bc,cd,cd | depart,new name right,new name left,arrive | [()],[(tunnel)],[()],[()] |
+
+    Scenario: Car - We tag classes without intersections
+        Background:
+            Given a grid size of 200 meters
+
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes | name | tunnel |
+            | ab    | road |        |
+            | bc    | road | yes    |
+            | cd    | road |        |
+
+        When I route I should get
+          | from | to | route     | turns         | classes               |
+          | a    | d  | road,road | depart,arrive | [(),(tunnel),()],[()] |
+
     Scenario: Car - From roundabout on toll road
         Given the node map
             """
@@ -124,4 +163,3 @@ Feature: Car - Mode flag
         When I route I should get
             | from | to | route       | turns                                                        | classes                                     |
             | a    | f  | ab,df,df,df | depart,roundabout-exit-2,exit roundabout slight right,arrive | [()],[(),(motorway)],[(toll,motorway)],[()] |
-

features/car/conditional_restrictions.feature

@@ -691,14 +691,14 @@ Feature: Car - Turn restrictions
         #    """
         Given the node locations
             | node | lat     | lon      |
-            | a    | 38.9113 | -77.0091 |
-            | b    | 38.9108 | -77.0091 |
-            | c    | 38.9104 | -77.0091 |
-            | d    | 38.9110 | -77.0096 |
-            | e    | 38.9106 | -77.0086 |
-            | f    | 38.9105 | -77.0090 |
-            | g    | 38.9108 | -77.0090 |
-            | h    | 38.9113 | -77.0090 |
+            | a    | 38.91124 | -77.00909 |
+            | b    | 38.91080 | -77.00909 |
+            | c    | 38.91038 | -77.00909 |
+            | d    | 38.91105 | -77.00967 |
+            | e    | 38.91037 | -77.00807 |
+            | f    | 38.91036 | -77.00899 |
+            | g    | 38.91076 | -77.00901 |
+            | h    | 38.91124 | -77.00900 |
 
         And the ways
             | nodes | oneway | name       |
@@ -719,7 +719,7 @@ Feature: Car - Turn restrictions
         When I route I should get
             | from | to | route                                      | turns                                       |
             | a    | e  | cap south,florida nw,florida nw,florida ne | depart,turn right,continue uturn,arrive     |
-            | f    | d  | cap north,florida,florida nw               | depart,turn left,arrive                     |
+            | f    | d  | cap north,florida nw,florida nw               | depart,turn left,arrive                     |
             | e    | c  | florida ne,florida nw,cap south,cap south  | depart,continue uturn,turn right,arrive     |
 
     @no_turning @conditionals
@@ -738,14 +738,14 @@ Feature: Car - Turn restrictions
         #    """
         Given the node locations
             | node | lat     | lon      |
-            | a    | 38.9113 | -77.0091 |
-            | b    | 38.9108 | -77.0091 |
-            | c    | 38.9104 | -77.0091 |
-            | d    | 38.9110 | -77.0096 |
-            | e    | 38.9106 | -77.0086 |
-            | f    | 38.9105 | -77.0090 |
-            | g    | 38.9108 | -77.0090 |
-            | h    | 38.9113 | -77.0090 |
+            | a    | 38.91124 | -77.00909 |
+            | b    | 38.91080 | -77.00909 |
+            | c    | 38.91038 | -77.00909 |
+            | d    | 38.91105 | -77.00967 |
+            | e    | 38.91037 | -77.00807 |
+            | f    | 38.91036 | -77.00899 |
+            | g    | 38.91076 | -77.00901 |
+            | h    | 38.91124 | -77.00900 |
 
         And the ways
             | nodes | oneway | name       |
@@ -765,7 +765,7 @@ Feature: Car - Turn restrictions
 
         When I route I should get
             | from | to | route                                      | turns                                         |
-            | a    | e  | cap south,florida,florida ne               | depart,turn left,arrive                       |
+            | a    | e  | cap south,florida ne,florida ne            | depart,turn left,arrive                       |
             | f    | d  | cap north,florida ne,florida ne,florida nw | depart,turn sharp right,continue uturn,arrive |
             | e    | c  | florida ne,cap south,cap south             | depart,turn left,arrive                       |
 

features/car/destination.feature

@@ -131,3 +131,58 @@ Feature: Car - Destination only, no passing through
             | e    | a  | acbe,acbe     |
             | d    | a  | de,acbe,acbe  |
             | c    | d  | cd,cd         |
+
+    Scenario: Car - Routing through a parking lot tagged access=destination,service
+        Given the node map
+            """
+               a----c++++b+++g------h---i
+               |    +    +   +     /
+               |    +    +   +    /
+               |    +    +  +    /
+               |    d++++e+f    /
+               z--------------y
+            """
+
+        And the ways
+            | nodes | access      | highway   |
+            | ac    |             | secondary |
+            | ghi   |             | secondary |
+            | azyhi |             | secondary |
+            | cd    | destination | service   |
+            | def   | destination | service   |
+            | cbg   | destination | service   |
+            | be    | destination | service   |
+            | gf    | destination | service   |
+
+        When I route I should get
+            | from | to | route               |
+            | a    | i  | azyhi,azyhi         |
+            | b    | f  | be,def,def          |
+            | b    | i  | cbg,ghi,azyhi,azyhi |
+
+    Scenario: Car - Disallow snapping to access=private,highway=service
+        Given a grid size of 20 meters
+        Given the node map
+            """
+               a---c---b
+                   :
+                   x
+                   :
+                   d
+                    \__e
+            """
+
+        And the ways
+            | nodes | access   | highway |
+            | acb   |          | primary |
+            | cx    | private  | service |
+            | xd    | private  | service |
+            | de    |          | primary |
+
+        When I route I should get
+            | from | to | route     |
+            | a    | x  | acb,xd,xd |
+            | a    | d  | acb,xd,xd |
+            | a    | e  | acb,xd,de |
+            | x    | e  | de,de     |
+            # do not snap to access=private,highway=service roads when routing over them is not necessary

features/car/physical_limitation.feature

@@ -39,7 +39,31 @@ Feature: Car - Handle physical limitation
     Scenario: Car - Limited by height
         Then routability should be
             | highway | maxheight:physical | maxheight | bothw |
+            | primary |                    |           | x     |
             | primary | 1                  |           |       |
             | primary | 3                  |           | x     |
             | primary |                    | 1         |       |
             | primary |                    | 3         | x     |
+            | primary |                    | default   | x     |
+            | primary |                    | none      | x     |
+            | primary |                    | no-sign   | x     |
+            | primary |                    | unsigned  | x     |
+
+    Scenario: Car - Limited by length
+        Then routability should be
+            | highway | maxlength | bothw |
+            | primary |           | x     |
+            | primary | 1         |       |
+            | primary | 5         | x     |
+            | primary | unsigned  | x     |
+
+    Scenario: Car - Limited by weight
+        Then routability should be
+            | highway | maxweight | bothw |
+            | primary |           | x     |
+            | primary | 1         |       |
+            | primary | 3.5       | x     |
+            | primary | 35000 kg  | x     |
+            | primary | 8.9t      | x     |
+            | primary | 0.1 lbs   |       |
+            | primary | unsigned  | x     |

features/car/restrictions.feature

@@ -141,6 +141,33 @@ Feature: Car - Turn restrictions
             | c    | a  | cj,aj,aj |
             | c    | b  | cj,bj,bj |
 
+    @no_turning
+    Scenario: Car - Ignore no_*_on_red relations
+        Given the node map
+            """
+              a
+            d j b
+              c
+            """
+
+        And the ways
+            | nodes | oneway |
+            | cj    | yes    |
+            | aj    | -1     |
+            | dj    | -1     |
+            | bj    | -1     |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction          |
+            | restriction | cj       | dj     | j        | no_turn_on_red       |
+            | restriction | cj       | bj     | j        | no_right_turn_on_red |
+
+        When I route I should get
+            | from | to | route    |
+            | c    | d  | cj,dj,dj |
+            | c    | a  | cj,aj,aj |
+            | c    | b  | cj,bj,bj |
+
     @only_turning
     Scenario: Car - Only left turn
         Given the node map
@@ -1034,3 +1061,28 @@ Feature: Car - Turn restrictions
         When I route I should get
             | from | to | route              |
             | a    | d  | ab,bc,bc,bge,de,de |
+
+
+    Scenario: Ambiguous ways
+        Given the node map
+            """
+            x---a----b-----c---z
+                     |
+                     d
+            """
+
+        And the ways
+            | nodes |
+            | abc   |
+            | bd    |
+            | xa    |
+            | cz    |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction  |
+            | restriction | bd       | abc    | b        | no_left_turn |
+
+        When I route I should get
+            | from | to | route        |
+            | d    | x  | bd,abc,xa,xa |
+            | d    | z  | bd,abc,cz,cz |

features/car/summaries.feature

@@ -76,7 +76,7 @@ Feature: Basic Routing
 
         When I route I should get
             | waypoints | route  | summary  |
-            | a,c       | ,      | 100, 101 |
+            | a,c       | ,,     | 100, 101 |
 
      Scenario: Single Ref
         Given the node map

features/foot/barrier.feature

@@ -19,7 +19,7 @@ Feature: Barriers
             | entrance       | x     |
             | wall           |       |
             | fence          |       |
-            | some_tag       |       |
+            | some_tag       | x     |
             | block          | x     |
 
     Scenario: Foot - Access tag trumphs barriers

features/guidance/bicycle-sliproads.feature

@@ -22,11 +22,11 @@ Feature: Bike - Mode flag
             | c    | traffic_signals |
 
         And the ways
-            | nodes | highway   | name   | oneway:bicycle |
-            | abcd  | cycleway  | street |                |
-            | eb    | path      |        | yes            |
-            | icef  | tertiary  | road   |                |
-            | geh   | secondary | street |                |
+            | nodes | highway   | name   | oneway:bicycle | maxspeed:forward  |
+            | abcd  | cycleway  | street |                | 4 km/h |
+            | eb    | path      |        | yes            |  |
+            | icef  | tertiary  | road   |                | 4 km/h |
+            | geh   | secondary | street |                |  |
 
         When I route I should get
             | waypoints | route             | turns                               |

features/guidance/bridges_and_tunnels.feature

@@ -98,11 +98,11 @@ Feature: Car - Guidance - Bridges and Tunnels
             | dce   | primary |        | Nebenstraße        |
 
         When I route I should get
-            | from | to | route                                      | turns                    |
-            | a    | d  | Hauptstraße,Nebenstraße,Nebenstraße        | depart,turn left,arrive  |
-            | a    | e  | Hauptstraße,Nebenstraße,Nebenstraße        | depart,turn right,arrive |
-            | e    | a  | Nebenstraße,Hauptstraßentunnel,Hauptstraße | depart,turn left,arrive  |
-            | d    | a  | Nebenstraße,Hauptstraßentunnel,Hauptstraße | depart,turn right,arrive |
+            | from | to | route                                      | turns                           |
+            | a    | d  | Hauptstraße,Nebenstraße,Nebenstraße        | depart,end of road left,arrive  |
+            | a    | e  | Hauptstraße,Nebenstraße,Nebenstraße        | depart,end of road right,arrive |
+            | e    | a  | Nebenstraße,Hauptstraßentunnel,Hauptstraße | depart,turn left,arrive         |
+            | d    | a  | Nebenstraße,Hauptstraßentunnel,Hauptstraße | depart,turn right,arrive        |
 
     Scenario: Tunnel with Immediate Turn Front and Back
         Given the node map
@@ -129,4 +129,3 @@ Feature: Car - Guidance - Bridges and Tunnels
             | e    | g  | Nebenstraße,Hauptstraßentunnel,Anderestraße,Anderestraße | depart,turn left,turn left,arrive   |
             | d    | f  | Nebenstraße,Hauptstraßentunnel,Anderestraße,Anderestraße | depart,turn right,turn right,arrive |
             | d    | g  | Nebenstraße,Hauptstraßentunnel,Anderestraße,Anderestraße | depart,turn right,turn left,arrive  |
-

features/guidance/collapse.feature

@@ -35,20 +35,20 @@ Feature: Collapse
             | waypoints | route                | turns                        | locations |
             | a,l       | first,second,second  | depart,turn right,arrive     | a,b,l     |
             | a,d       | first,first          | depart,arrive                | a,d       |
-            | a,j       | first,second,second  | depart,turn left,arrive      | a,c,j     |
-            | a,h       | first,first,first    | depart,continue uturn,arrive | a,c,h     |
+            | a,j       | first,second,second  | depart,turn left,arrive      | a,b,j     |
+            | a,h       | first,first,first    | depart,continue uturn,arrive | a,b,h     |
             | e,j       | first,second,second  | depart,turn right,arrive     | e,f,j     |
             | e,h       | first,first          | depart,arrive                | e,h       |
-            | e,l       | first,second,second  | depart,turn left,arrive      | e,g,l     |
-            | e,d       | first,first,first    | depart,continue uturn,arrive | e,g,d     |
+            | e,l       | first,second,second  | depart,turn left,arrive      | e,f,l     |
+            | e,d       | first,first,first    | depart,continue uturn,arrive | e,f,d     |
             | k,h       | second,first,first   | depart,turn right,arrive     | k,g,h     |
             | k,l       | second,second        | depart,arrive                | k,l       |
-            | k,d       | second,first,first   | depart,turn left,arrive      | k,b,d     |
-            | k,j       | second,second,second | depart,continue uturn,arrive | k,b,j     |
+            | k,d       | second,first,first   | depart,turn left,arrive      | k,g,d     |
+            | k,j       | second,second,second | depart,continue uturn,arrive | k,g,j     |
             | i,d       | second,first,first   | depart,turn right,arrive     | i,c,d     |
             | i,j       | second,second        | depart,arrive                | i,j       |
-            | i,h       | second,first,first   | depart,turn left,arrive      | i,f,h     |
-            | i,l       | second,second,second | depart,continue uturn,arrive | i,f,l     |
+            | i,h       | second,first,first   | depart,turn left,arrive      | i,c,h     |
+            | i,l       | second,second,second | depart,continue uturn,arrive | i,c,l     |
 
    	Scenario: Segregated Intersection, Cross Belonging to Single Street
         Given the node map
@@ -74,7 +74,7 @@ Feature: Collapse
 
         When I route I should get
             | waypoints | route                      | turns                                      | locations |
-            | a,i       | first,second,third,third   | depart,turn left,turn slight left,arrive   | a,b,e,i   |
+            | a,i       | first,third,third   | depart,turn sharp left,arrive   | a,b,i   |
 
     Scenario: Segregated Intersection, Cross Belonging to Correct Street
         Given the node map
@@ -106,20 +106,20 @@ Feature: Collapse
             | waypoints | route                | turns                        | locations |
             | a,l       | first,second,second  | depart,turn right,arrive     | a,b,l     |
             | a,d       | first,first          | depart,arrive                | a,d       |
-            | a,j       | first,second,second  | depart,turn left,arrive      | a,c,j     |
-            | a,h       | first,first,first    | depart,continue uturn,arrive | a,c,h     |
+            | a,j       | first,second,second  | depart,turn left,arrive      | a,b,j     |
+            | a,h       | first,first,first    | depart,continue uturn,arrive | a,b,h     |
             | e,j       | first,second,second  | depart,turn right,arrive     | e,f,j     |
             | e,h       | first,first          | depart,arrive                | e,h       |
-            | e,l       | first,second,second  | depart,turn left,arrive      | e,g,l     |
-            | e,d       | first,first,first    | depart,continue uturn,arrive | e,g,d     |
+            | e,l       | first,second,second  | depart,turn left,arrive      | e,f,l     |
+            | e,d       | first,first,first    | depart,continue uturn,arrive | e,f,d     |
             | k,h       | second,first,first   | depart,turn right,arrive     | k,g,h     |
             | k,l       | second,second        | depart,arrive                | k,l       |
-            | k,d       | second,first,first   | depart,turn left,arrive      | k,b,d     |
-            | k,j       | second,second,second | depart,continue uturn,arrive | k,b,j     |
+            | k,d       | second,first,first   | depart,turn left,arrive      | k,g,d     |
+            | k,j       | second,second,second | depart,continue uturn,arrive | k,g,j     |
             | i,d       | second,first,first   | depart,turn right,arrive     | i,c,d     |
             | i,j       | second,second        | depart,arrive                | i,j       |
-            | i,h       | second,first,first   | depart,turn left,arrive      | i,f,h     |
-            | i,l       | second,second,second | depart,continue uturn,arrive | i,f,l     |
+            | i,h       | second,first,first   | depart,turn left,arrive      | i,c,h     |
+            | i,l       | second,second,second | depart,continue uturn,arrive | i,c,l     |
 
     Scenario: Segregated Intersection, Cross Belonging to Mixed Streets
         Given the node map
@@ -151,20 +151,20 @@ Feature: Collapse
             | waypoints | route                | turns                        | locations |
             | a,l       | first,second,second  | depart,turn right,arrive     | a,b,l     |
             | a,d       | first,first          | depart,arrive                | a,d       |
-            | a,j       | first,second,second  | depart,turn left,arrive      | a,c,j     |
-            | a,h       | first,first,first    | depart,continue uturn,arrive | a,c,h     |
+            | a,j       | first,second,second  | depart,turn left,arrive      | a,b,j     |
+            | a,h       | first,first,first    | depart,continue uturn,arrive | a,b,h     |
             | e,j       | first,second,second  | depart,turn right,arrive     | e,f,j     |
             | e,h       | first,first          | depart,arrive                | e,h       |
-            | e,l       | first,second,second  | depart,turn left,arrive      | e,g,l     |
-            | e,d       | first,first,first    | depart,continue uturn,arrive | e,g,d     |
+            | e,l       | first,second,second  | depart,turn left,arrive      | e,f,l     |
+            | e,d       | first,first,first    | depart,continue uturn,arrive | e,f,d     |
             | k,h       | second,first,first   | depart,turn right,arrive     | k,g,h     |
             | k,l       | second,second        | depart,arrive                | k,l       |
-            | k,d       | second,first,first   | depart,turn left,arrive      | k,b,d     |
-            | k,j       | second,second,second | depart,continue uturn,arrive | k,b,j     |
+            | k,d       | second,first,first   | depart,turn left,arrive      | k,g,d     |
+            | k,j       | second,second,second | depart,continue uturn,arrive | k,g,j     |
             | i,d       | second,first,first   | depart,turn right,arrive     | i,c,d     |
             | i,j       | second,second        | depart,arrive                | i,j       |
-            | i,h       | second,first,first   | depart,turn left,arrive      | i,f,h     |
-            | i,l       | second,second,second | depart,continue uturn,arrive | i,f,l     |
+            | i,h       | second,first,first   | depart,turn left,arrive      | i,c,h     |
+            | i,l       | second,second,second | depart,continue uturn,arrive | i,c,l     |
 
     Scenario: Partly Segregated Intersection, Two Segregated Roads
         Given the node map
@@ -209,11 +209,11 @@ Feature: Collapse
             | d,c       | first,first,first    | depart,continue uturn,arrive | d,e,c     |
             | g,c       | second,first,first   | depart,turn right,arrive     | g,b,c     |
             | g,j       | second,second        | depart,arrive                | g,j       |
-            | g,f       | second,first,first   | depart,turn left,arrive      | g,e,f     |
+            | g,f       | second,first,first   | depart,turn left,arrive      | g,b,f     |
             | g,h       | second,second,second | depart,continue uturn,arrive | g,b,h     |
             | i,f       | second,first,first   | depart,turn right,arrive     | i,e,f     |
             | i,h       | second,second        | depart,arrive                | i,h       |
-            | i,c       | second,first,first   | depart,turn left,arrive      | i,b,c     |
+            | i,c       | second,first,first   | depart,turn left,arrive      | i,e,c     |
             | i,j       | second,second,second | depart,continue uturn,arrive | i,e,j     |
 
     Scenario: Partly Segregated Intersection, Two Segregated Roads, Intersection belongs to Second
@@ -263,11 +263,11 @@ Feature: Collapse
             | d,c       | first,first,first    | depart,continue uturn,arrive | d,e,c     |
             | g,c       | second,first,first   | depart,turn right,arrive     | g,b,c     |
             | g,j       | second,second        | depart,arrive                | g,j       |
-            | g,f       | second,first,first   | depart,turn left,arrive      | g,e,f     |
+            | g,f       | second,first,first   | depart,turn left,arrive      | g,b,f     |
             | g,h       | second,second,second | depart,continue uturn,arrive | g,b,h     |
             | i,f       | second,first,first   | depart,turn right,arrive     | i,e,f     |
             | i,h       | second,second        | depart,arrive                | i,h       |
-            | i,c       | second,first,first   | depart,turn left,arrive      | i,b,c     |
+            | i,c       | second,first,first   | depart,turn left,arrive      | i,e,c     |
             | i,j       | second,second,second | depart,continue uturn,arrive | i,e,j     |
 
     Scenario: Segregated Intersection, Cross Belonging to Mixed Streets - Slight Angles
@@ -300,20 +300,20 @@ Feature: Collapse
             | waypoints | route                | turns                        | locations |
             | a,l       | first,second,second  | depart,turn right,arrive     | a,b,l     |
             | a,d       | first,first          | depart,arrive                | a,d       |
-            | a,j       | first,second,second  | depart,turn left,arrive      | a,c,j     |
-            | a,h       | first,first,first    | depart,continue uturn,arrive | a,c,h     |
+            | a,j       | first,second,second  | depart,turn left,arrive      | a,b,j     |
+            | a,h       | first,first,first    | depart,continue uturn,arrive | a,b,h     |
             | e,j       | first,second,second  | depart,turn right,arrive     | e,f,j     |
             | e,h       | first,first          | depart,arrive                | e,h       |
-            | e,l       | first,second,second  | depart,turn left,arrive      | e,g,l     |
-            | e,d       | first,first,first    | depart,continue uturn,arrive | e,g,d     |
+            | e,l       | first,second,second  | depart,turn left,arrive      | e,f,l     |
+            | e,d       | first,first,first    | depart,continue uturn,arrive | e,f,d     |
             | k,h       | second,first,first   | depart,turn right,arrive     | k,g,h     |
             | k,l       | second,second        | depart,arrive                | k,l       |
-            | k,d       | second,first,first   | depart,turn left,arrive      | k,b,d     |
-            | k,j       | second,second,second | depart,continue uturn,arrive | k,b,j     |
+            | k,d       | second,first,first   | depart,turn left,arrive      | k,g,d     |
+            | k,j       | second,second,second | depart,continue uturn,arrive | k,g,j     |
             | i,d       | second,first,first   | depart,turn right,arrive     | i,c,d     |
             | i,j       | second,second        | depart,arrive                | i,j       |
-            | i,h       | second,first,first   | depart,turn left,arrive      | i,f,h     |
-            | i,l       | second,second,second | depart,continue uturn,arrive | i,f,l     |
+            | i,h       | second,first,first   | depart,turn left,arrive      | i,c,h     |
+            | i,l       | second,second,second | depart,continue uturn,arrive | i,c,l     |
 
     Scenario: Segregated Intersection, Cross Belonging to Mixed Streets - Slight Angles (2)
         Given the node map
@@ -345,28 +345,29 @@ Feature: Collapse
             | waypoints | route                | turns                        | locations |
             | a,l       | first,second,second  | depart,turn right,arrive     | a,b,l     |
             | a,d       | first,first          | depart,arrive                | a,d       |
-            | a,j       | first,second,second  | depart,turn left,arrive      | a,c,j     |
-            | a,h       | first,first,first    | depart,continue uturn,arrive | a,c,h     |
+            | a,j       | first,second,second  | depart,turn left,arrive      | a,b,j     |
+            | a,h       | first,first,first    | depart,continue uturn,arrive | a,b,h     |
             | e,j       | first,second,second  | depart,turn right,arrive     | e,f,j     |
             | e,h       | first,first          | depart,arrive                | e,h       |
-            | e,l       | first,second,second  | depart,turn left,arrive      | e,g,l     |
-            | e,d       | first,first,first    | depart,continue uturn,arrive | e,g,d     |
+            | e,l       | first,second,second  | depart,turn left,arrive      | e,f,l     |
+            | e,d       | first,first,first    | depart,continue uturn,arrive | e,f,d     |
             | k,h       | second,first,first   | depart,turn right,arrive     | k,g,h     |
             | k,l       | second,second        | depart,arrive                | k,l       |
-            | k,d       | second,first,first   | depart,turn left,arrive      | k,b,d     |
-            | k,j       | second,second,second | depart,continue uturn,arrive | k,b,j     |
+            | k,d       | second,first,first   | depart,turn left,arrive      | k,g,d     |
+            | k,j       | second,second,second | depart,continue uturn,arrive | k,g,j     |
             | i,d       | second,first,first   | depart,turn right,arrive     | i,c,d     |
             | i,j       | second,second        | depart,arrive                | i,j       |
-            | i,h       | second,first,first   | depart,turn left,arrive      | i,f,h     |
-            | i,l       | second,second,second | depart,continue uturn,arrive | i,f,l     |
+            | i,h       | second,first,first   | depart,turn left,arrive      | i,c,h     |
+            | i,l       | second,second,second | depart,continue uturn,arrive | i,c,l     |
 
     Scenario: Entering a segregated road
         Given the node map
             """
-              a f       g
-              | |   . '
-              b-e '
-              / /
+                    h
+              a f   |   g
+              | |   i '
+              b-e ' |
+              / /   j
              / /
             c d
             """
@@ -376,7 +377,8 @@ Feature: Collapse
             | abc   | primary | first  | yes    |
             | def   | primary | first  | yes    |
             | be    | primary | first  | no     |
-            | ge    | primary | second | no     |
+            | gie   | primary | second | no     |
+            | hij   | primary | maple  | no     |
 
         When I route I should get
             | waypoints | route               | turns                          | locations |
@@ -385,7 +387,7 @@ Feature: Collapse
             | a,g       | first,second,second | depart,turn left,arrive        | a,b,g     |
             | d,g       | first,second,second | depart,turn right,arrive       | d,e,g     |
             | g,f       | second,first,first  | depart,turn right,arrive       | g,e,f     |
-            | g,c       | second,first,first  | depart,turn left,arrive        | g,e,c     |
+            | g,c       | second,first,first  | depart,end of road left,arrive | g,e,c     |
 
     Scenario: Do not collapse turning roads
         Given the node map
@@ -603,7 +605,7 @@ Feature: Collapse
 
         When I route I should get
             | waypoints | route        | turns                           | locations |
-            | i,h       | in,road,road | depart,turn left,arrive         | i,f,h     |
+            | i,h       | in,road,road | depart,turn slight left,arrive  | i,c,h     |
             | a,d       | road,road    | depart,arrive                   | a,d       |
             | a,j       | road,out,out | depart,turn slight right,arrive | a,b,j     |
 
@@ -1010,7 +1012,7 @@ Feature: Collapse
             | f,j       | hohe,hohe             | depart,arrive               | f,j       |
             | a,t       | hohe,a100,a100        | depart,on ramp right,arrive | a,b,t     |
             | f,e       |                       |                             |           |
-            | q,j       | a100,hohe,hohe        | depart,turn right,arrive    | q,p,j     |
+            | q,j       | a100,hohe,hohe        | depart,turn right,arrive    | q,i,j     |
             | q,e       | a100,hohebruecke,hohe | depart,turn left,arrive     | q,p,e     |
 
     Scenario: Forking before a turn (forky)

features/guidance/dedicated-turn-roads.feature

@@ -687,7 +687,7 @@ Feature: Slipways and Dedicated Turn Lanes
 
        When I route I should get
             | waypoints | route             | turns                                      | locations |
-            | s,f       | sabc,ae,dbef,dbef | depart,turn slight right,turn right,arrive | s,a,e,f   |
+            | s,f       | sabc,ae,dbef,dbef | depart,fork slight right,turn right,arrive | s,a,e,f   |
 
     @sliproads
     Scenario: Traffic Signal on Sliproad

features/guidance/divided-highways.feature

@@ -13,19 +13,23 @@ Feature: Divided road entry
             d-------e-----f
                     |
                     |
-                    g
+                i---g---j
+                    |
+                    |
+                    h
             """
 
         And the ways
-            | nodes  | name    | highway     | oneway |
-            | abc    | main st | residential | -1     |
-            | def    | main st | residential | yes    |
-            | be     | main st | residential |        |
-            | eg     | side st | residential |        |
+            | nodes  | name     | highway     | oneway |
+            | abc    | main st  | residential | -1     |
+            | def    | main st  | residential | yes    |
+            | be     | main st  | residential |        |
+            | egh    | side st  | residential |        |
+            | igj    | maple st | residential |        |
 
        When I route I should get
             | waypoints | route                  | turns                   |
-            | g,a       | side st,main st,main st| depart,end of road left,arrive |
+            | h,a       | side st,main st,main st| depart,end of road left,arrive |
 
 
     # Similar to previous one, but the joining way is tagged with the side-street name
@@ -37,18 +41,22 @@ Feature: Divided road entry
             d-------e-----f
                     |
                     |
-                    g
+                i---g---j
+                    |
+                    |
+                    h
             """
 
         And the ways
-            | nodes  | name    | highway     | oneway |
-            | abc    | main st | residential | -1     |
-            | def    | main st | residential | yes    |
-            | beg    | side st | residential |        |
+            | nodes  | name     | highway     | oneway |
+            | abc    | main st  | residential | -1     |
+            | def    | main st  | residential | yes    |
+            | begh   | side st  | residential |        |
+            | igj    | maple st | residential |        |
 
        When I route I should get
             | waypoints | route    | turns                           |
-            | g,a       | side st,main st,main st| depart,end of road left,arrive |
+            | h,a       | side st,main st,main st| depart,end of road left,arrive |
 
 
     # Center join named after crossroad
@@ -100,3 +108,32 @@ Feature: Divided road entry
        When I route I should get
             | waypoints | route    | turns                           |
             | g,a       | side st,main st,main st| depart,turn left,arrive |
+
+    # Verify end of road left turn across divided roads
+    Scenario: Join on a divided road, named after the side street
+        Given the node map
+            """
+            a-----h--b-----c
+                  |  |
+            d-----i--e-----f
+                  |  |
+                  |  |
+              m---j--g---n
+                  |  |
+                  |  |
+                  k  l
+            """
+
+        And the ways
+            | nodes  | name    | highway     | oneway |
+            | ahbc   | main st | residential | -1     |
+            | dief   | main st | residential | yes    |
+            | begl   | side st | residential | -1     |
+            | hijk   | side st | residential | yes    |
+            | mjgn   | maple st| residential | no     |
+
+       When I route I should get
+            | waypoints | route    | turns                           |
+            | l,a       | side st,main st,main st| depart,end of road left,arrive |
+
+

features/guidance/driveway.feature

@@ -46,3 +46,23 @@ Feature: Driveways intersections
        When I route I should get
           | waypoints | route   | turns         | locations |
           | a,d       | ,second | depart,arrive | a,d       |
+
+
+    Scenario: Road with a turn to service road
+        Given the node map
+          """
+               /-----------------e
+          a---b------------------c
+               `-----------------d
+          """
+
+        And the ways
+          | nodes | highway | name | oneway |
+          | abc   | trunk   | road | yes    |
+          | bd    | service | serv | yes    |
+          | be    | service | serv | yes    |
+
+       When I route I should get
+          | waypoints | route          | turns                           | locations |
+          | a,d       | road,serv,serv | depart,turn slight right,arrive | a,b,d     |
+          | a,e       | road,serv,serv | depart,turn slight left,arrive  | a,b,e     |

features/guidance/internal-intersections.feature

@@ -0,0 +1,46 @@
+@guidance
+Feature: Internal Intersection Model
+
+    Background:
+        Given the profile "car"
+        Given a grid size of 10 meters
+
+    Scenario: Dual-carriage way intersection
+        Given the node map
+          """
+             a  b
+             |  |
+          c--d--e--f
+             |  |
+          g--h--i--j
+             |  |
+             k  l
+          """
+
+        And the ways
+          | nodes | oneway | name                  |
+          | adhk  | yes    | Broken Land Parkway   |
+          | lieb  | yes    | Broken Land Parkway   |
+          | fed   | yes    | Snowden River Parkway |
+          | dc    | yes    | Patuxent Woods Drive  |
+          | gh    | yes    | Patuxent Woods Drive  |
+          | hij   | yes    | Snowden River Parkway |
+
+        When I route I should get
+          | waypoints | route                                                              | turns                        | # |
+          | a,k       | Broken Land Parkway,Broken Land Parkway                            | depart,arrive                ||
+          | l,b       | Broken Land Parkway,Broken Land Parkway                            | depart,arrive                ||
+#         | g,j       | Patuxent Woods Drive,Snowden River Parkway,Snowden River Parkway   | depart,continue,arrive       | did not work as expected - might be another issue to handle in post process? |
+#         | f,c       | Snowden River Parkway,Patuxent Woods Drive,Patuxent Woods Drive    | depart,continue,arrive       | did not work as expected - might be another issue to handle in post process? |
+          | a,c       | Broken Land Parkway,Patuxent Woods Drive,Patuxent Woods Drive      | depart,turn right,arrive     ||
+          | g,k       | Patuxent Woods Drive,Broken Land Parkway,Broken Land Parkway       | depart,turn right,arrive     ||
+          | l,j       | Broken Land Parkway,Snowden River Parkway,Snowden River Parkway    | depart,turn right,arrive     ||
+          | f,b       | Snowden River Parkway,Broken Land Parkway,Broken Land Parkway      | depart,turn right,arrive     ||
+          | a,j       | Broken Land Parkway,Snowden River Parkway,Snowden River Parkway    | depart,turn left,arrive      ||
+          | g,b       | Patuxent Woods Drive,Broken Land Parkway,Broken Land Parkway       | depart,turn left,arrive      ||
+          | l,c       | Broken Land Parkway,Patuxent Woods Drive,Patuxent Woods Drive      | depart,turn left,arrive      ||
+          | f,k       | Snowden River Parkway,Broken Land Parkway,Broken Land Parkway      | depart,turn left,arrive      ||
+          | a,b       | Broken Land Parkway,Broken Land Parkway,Broken Land Parkway        | depart,continue uturn,arrive ||
+          | g,c       | Patuxent Woods Drive,Patuxent Woods Drive,Patuxent Woods Drive     | depart,continue uturn,arrive ||
+          | l,k       | Broken Land Parkway,Broken Land Parkway,Broken Land Parkway        | depart,continue uturn,arrive ||
+          | f,j       | Snowden River Parkway,Snowden River Parkway,Snowden River Parkway  | depart,continue uturn,arrive ||

features/guidance/low-priority.feature

@@ -64,9 +64,9 @@ Feature: Exceptions for routing onto low-priority roads
             | bc     | service     |         |
 
        When I route I should get
-            | waypoints | route             | turns                       |
-            | e,c       | service,          | depart,arrive               |
-            | c,e       | ,service,service  | depart,turn straight,arrive |
+            | waypoints | route    | turns         |
+            | e,c       | service, | depart,arrive |
+            | c,e       | ,service | depart,arrive |
 
     Scenario: Straight onto low-priority
         Given the node map

features/guidance/maneuver-tag.feature

@@ -0,0 +1,232 @@
+# The route results with #original are what the result should be if the maneuver tag is removed
+@routing @guidance @maneuver
+Feature: Maneuver tag support
+
+    Background:
+        Given the profile "car"
+        Given a grid size of 5 meters
+
+    Scenario: simple override #1
+        Given the node map
+            """
+            a--b---c----d---e
+                   |
+                   g
+                   |
+            h------i--------j
+            """
+        And the ways
+            | nodes | name     | oneway |
+            | abc   | A Street | no     |
+            | cde   | B Street | no     |
+            | cgi   | C Street | no     |
+            | hij   | J Street | no     |
+
+        And the relations
+            | type     | way:from | node:via | way:to | maneuver | direction   |
+            | maneuver | abc      | c        | cgi    | turn     | sharp_right |
+            | maneuver | hij      | i        | cde    | turn     | sharp_left  |
+            | maneuver | abc      | c        | cde    | turn     | slight_left |
+            | maneuver | cde      | c        | cgi    | turn     | straight    |
+            | manoeuvre| cgi      | c        | abc    | turn     | right       |
+
+        And the relations
+            | type      | way:from | node:via | way:to | manoeuvre | maneuver | direction    |
+            | maneuver  | cgi      | c        | cde    | fork      | turn     | slight_right |
+
+        When I route I should get
+            | waypoints | route                               | turns                                    |
+        # Testing directly connected from/to
+            | a,j       | A Street,C Street,J Street,J Street | depart,turn sharp right,turn left,arrive |
+            | b,g       | A Street,C Street,C Street          | depart,turn sharp right,arrive           |
+        # Testing re-awakening suppressed turns
+            | a,e       | A Street,B Street,B Street          | depart,turn slight left,arrive           |
+            | e,i       | B Street,C Street,C Street          | depart,turn straight,arrive              |
+            | i,e       | C Street,B Street,B Street          | depart,fork slight right,arrive          |
+            | i,a       | C Street,A Street,A Street          | depart,turn right,arrive                 |
+
+    Scenario: single via-way
+      Given the node map
+          """"
+            a--b---c----d---e
+                   |
+                   g
+                   |
+            h------i--------j
+          """
+
+        And the ways
+            | nodes | name     | oneway |
+            | abc   | A Street | no     |
+            | cde   | B Street | no     |
+            | cgi   | C Street | no     |
+            | hi    | J Street | no     |
+            | ij    | J Street | no     |
+
+        And the relations
+            | type     | way:from | way:via | way:to | node:via | maneuver | direction   |
+            | maneuver | abc      | cgi     | ij     | c        | turn     | sharp_right |
+
+        When I route I should get
+            | waypoints | route                               | turns                                    |
+            | a,j       | A Street,C Street,J Street,J Street | depart,turn sharp right,turn left,arrive |
+
+
+    Scenario: multiple via-way
+      Given the node map
+          """"
+            a--b---c----d---e
+                   |
+                   g-----k
+                   |
+            h------i--------j
+          """
+
+        And the ways
+            | nodes | name     | oneway |
+            | abc   | A Street | no     |
+            | cde   | B Street | no     |
+            | cg    | C Street | no     |
+            | gi    | C Street | no     |
+            | hi    | J Street | no     |
+            | ij    | J Street | no     |
+            | gk    | G Street | no     |
+
+        And the relations
+            | type     | way:from | way:via | way:via | way:to | node:via | maneuver | direction   |
+            | maneuver | abc      | cg      | gi      | ij     | c        | turn     | sharp_right |
+
+        When I route I should get
+            | waypoints | route                               | turns                                    |
+            | a,j       | A Street,C Street,J Street,J Street | depart,turn sharp right,end of road left,arrive |
+
+
+    Scenario: Use maneuver tag to announce a particular turn type
+        Given the node map
+            """
+            f
+            *
+            *
+             *
+              *
+                *
+                  *
+                    *
+                     *
+                      *
+             t. ..     *                h
+                  .. ....m**           *
+                        /    *       *
+                       /       * * *
+                      /
+                     /
+                    |
+                    |
+                     \
+                      \
+                       o
+            """
+
+        And the ways
+            | nodes | name      | oneway | highway      |
+            | fm    | CA-120    | no     | secondary    |
+            | mh    | CA-120    | no     | secondary    |
+            | mt    | Priest Rd | no     | unclassified |
+            | mo    |           | no     | service      |
+
+        And the relations
+            | type     | way:from | node:via | way:to | maneuver | direction |
+            | maneuver | mh       | m        | mt     | turn     | left      |
+
+        When I route I should get
+            | waypoints | route                        | turns                        |
+            | h,t       | CA-120,Priest Rd,Priest Rd   | depart,turn left,arrive      |
+  #original | h,t       | CA-120,Priest Rd,Priest Rd   | depart,turn straight,arrive  |
+
+    Scenario: Use maneuver tag to announce lane guidance
+        Given a grid size of 10 meters
+        Given the node map
+            """
+               ad
+              / \
+             /   \
+            /     \
+            |     |
+            |     |
+            |     |
+            b-----c------e
+            |     |
+            |     |
+            |     |
+            |     |
+            r     w
+            """
+
+        And the ways
+            | nodes | name      | oneway | highway   |
+            | ab    | Marsh Rd  | yes    | secondary |
+            | br    | Marsh Rd  | yes    | secondary |
+            | cd    | Marsh Rd  | yes    | secondary |
+            | cw    | Marsh Rd  | yes    | secondary |
+            | bc    | service   | no     | service   |
+            | ce    | service   | no     | service   |
+
+        And the relations
+            | type     | way:from | node:via | way:via | way:to | maneuver |
+            | maneuver | ab       | c        | bc      | cd     | uturn    |
+            | maneuver | ab       | b        | bc      | cd     | suppress |
+
+        When I route I should get
+            | waypoints | route                         | turns                    |
+            | a,d       | Marsh Rd,Marsh Rd,Marsh Rd    | depart,turn uturn,arrive |
+  #original | a,d       | Marsh Rd,service,Marsh Rd,Marsh Rd | depart,turn left,turn left,arrive |
+
+    Scenario: Use maneuver tag to suppress a turn
+        Given the node map
+            """
+              c
+              |
+              |
+          v---y----------z
+              |
+          n---p----------k
+              |\
+              | \
+              b  t
+            """
+
+        And the ways
+            | nodes | name    | oneway | highway       |
+            | zy    | NY Ave  | yes    | primary       |
+            | yv    | NY Ave  | yes    | primary       |
+            | np    | NY Ave  | yes    | primary       |
+            | pk    | NY Ave  | yes    | primary       |
+            | cp    | 4th St  | no     | tertiary      |
+            | yp    |         | no     | motorway_link |
+            | pb    | 4th St  | no     | primary       |
+            | pt    | 395     | no     | primary       |
+
+        And the relations
+            | type     | way:from | node:via | way:via | way:to | maneuver | #                                                     |
+            | maneuver | zy       | p        | yp      | pt     | suppress | original: depart,on ramp left,fork slight left,arrive |
+
+        And the relations
+            | type     | way:from | way:via | way:to | maneuver | #                                  |
+            | maneuver | zy       | yp      | pb     | suppress | invalid relation: missing node:via |
+
+        And the relations
+            | type     | node:via | way:via | way:to | maneuver | #                                  |
+            | maneuver | p        | yp      | pb     | suppress | invalid relation: missing way:from |
+
+        And the relations
+            | type     | way:from | node:via | way:via | maneuver | #                                |
+            | maneuver | zy       | p        | yp      | suppress | invalid relation: missing way:to |
+
+        And the relations
+            | type     | way:from | node:via | way:via | way:to | maneuver | #                                   |
+            | maneuver | zy       | y, p     | yp      | pb     | suppress | invalid relation: multiple node:via |
+
+        When I route I should get
+            | waypoints | route                 | turns                                        |
+            | z,t       | NY Ave,395,395        | depart,on ramp left,arrive                   |
+            | z,b       | NY Ave,,4th St,4th St | depart,on ramp left,fork slight right,arrive |

features/guidance/merge-segregated-roads.feature

@@ -384,9 +384,9 @@ Feature: Merge Segregated Roads
             | cd    | right  | no     |
 
         When I route I should get
-            | waypoints | route                           | intersections                                                                                       |
-            | a,d       | left,circle,circle,right,right  | true:90;false:90 true:120 false:270;true:60 true:180 false:300;true:90 false:240 true:270;true:270  |
-            | g,d       | bottom,circle,right,right       | true:0;true:60 false:180 false:300;true:90 false:240 true:270;true:270                              |
+            | waypoints | route                     | intersections                                                                                      |
+            | a,d       | left,circle,right,right   | true:90,false:90 true:120 false:270;true:60 true:180 false:300;true:90 false:240 true:270;true:270 |
+            | g,d       | bottom,circle,right,right | true:0;true:60 false:180 false:300;true:90 false:240 true:270;true:270                             |
 
     Scenario: Middle Island
         Given the node map
@@ -644,7 +644,7 @@ Feature: Merge Segregated Roads
             | k,j       | marianne,albrecht,luise,luise      | depart,turn left,turn left,arrive              |
             | k,d       | marianne,schwert,schwert           | depart,turn right,arrive                       |
             | i,j       | luise,luise                        | depart,arrive                                  |
-            | i,d       | luise,albrecht,schwert,schwert     | depart,turn left,turn straight,arrive          |
+            | i,d       | luise,albrecht,schwert             | depart,turn left,arrive                        |
             | i,l       | luise,albrecht,marianne,marianne   | depart,turn left,turn left,arrive              |
 
     # https://www.openstreetmap.org/#map=19/52.46339/13.40272

features/guidance/motorway.feature

@@ -81,7 +81,7 @@ Feature: Motorway Guidance
             """
                  ,g,e
                ,f,d
-            a-b-c 
+            a-b-c
             """
 
         And the ways
@@ -201,7 +201,7 @@ Feature: Motorway Guidance
             | a,e       | abcde,abcde     | depart,arrive                      |
             | f,e       | fgc,abcde,abcde | depart,merge slight left,arrive    |
             | a,i       | abcde,chi,chi   | depart,off ramp slight right,arrive |
-            | f,i       | fgc,chi,chi     | depart,off ramp right,arrive       |
+            | f,i       | fgc,chi,chi     | depart,off ramp slight right,arrive |
 
     Scenario: On And Off Ramp Left
        Given the node map
@@ -221,7 +221,7 @@ Feature: Motorway Guidance
             | a,e       | abcde,abcde     | depart,arrive                     |
             | f,e       | fgc,abcde,abcde | depart,merge slight right,arrive  |
             | a,i       | abcde,chi,chi   | depart,off ramp slight left,arrive |
-            | f,i       | fgc,chi,chi     | depart,off ramp left,arrive       |
+            | f,i       | fgc,chi,chi     | depart,off ramp slight left,arrive |
 
     Scenario: Merging Motorways
         Given the node map
@@ -281,3 +281,67 @@ Feature: Motorway Guidance
             | waypoints | route | turns         |
             | a,d       | ,     | depart,arrive |
             | b,d       | ,     | depart,arrive |
+
+
+    Scenario: Ramp Exit with Lower Priority
+        Given the node map
+            """
+            a-b-c-d-e
+               `--f-g
+            """
+
+        And the ways
+            | nodes | highway      | oneway |
+            | abcde | trunk        |        |
+            | bfg   | primary_link | yes    |
+
+       When I route I should get
+            | waypoints | route         | turns                               |
+            | a,e       | abcde,abcde   | depart,arrive                       |
+            | a,g       | abcde,bfg,bfg | depart,off ramp slight right,arrive |
+
+
+    # https://www.openstreetmap.org/node/67366428#map=18/33.64613/-84.44425
+    Scenario: Ramp Bifurcations should not be suppressed
+        Given the node map
+            """
+                 /-----------c      /-----------e
+            a---b------------------d------------f
+            """
+
+        And the ways
+            | nodes | highway       | name | destination                                         |
+            | ab    | motorway      |      |                                                     |
+            | bc    | motorway_link |      | City 17                                             |
+            | bd    | motorway_link |      |                                                     |
+            | de    | motorway_link |      | Domestic Terminal;Camp Creek Parkway;Riverdale Road |
+            | df    | motorway_link |      | Montgomery                                          |
+
+
+       When I route I should get
+            | waypoints | route | turns                                            |
+            | a,c       | ,,    | depart,fork slight left,arrive                   |
+            | a,e       | ,,,   | depart,fork slight right,fork slight left,arrive  |
+            | a,f       | ,,,   | depart,fork slight right,fork slight right,arrive |
+
+
+    # https://www.openstreetmap.org/#map=19/53.46186/-2.24509
+    Scenario: Highway Fork with a Link
+        Given the node map
+            """
+                 /-----------d
+            a-b-c------------e
+                 \-----------f
+            """
+
+        And the ways
+            | nodes | highway       |
+            | abce  | motorway      |
+            | cf    | motorway      |
+            | cd    | motorway_link |
+
+       When I route I should get
+            | waypoints | route      | turns                              |
+            | a,d       | abce,cd,cd | depart,off ramp slight left,arrive |
+            | a,e       | abce,abce  | depart,arrive                      |
+            | a,f       | abce,cf,cf | depart,turn slight right,arrive |

features/guidance/new-name.feature

@@ -382,6 +382,21 @@ Feature: New-Name Instructions
             | waypoints | route | turns         |
             | a,c       | ,     | depart,arrive |
 
+    Scenario: No Name, Reference changed
+        Given the node map
+            """
+            a ----- b ----- c
+            """
+
+        And the ways
+            | nodes | name | ref    | highway  |
+            | ab    |      | US 322 | motorway |
+            | bc    |      | US 422 | motorway |
+
+        When I route I should get
+            | waypoints | route | turns                           |
+            | a,c       | ,,    | depart,new name straight,arrive |
+
     Scenario: Spaces in refs for containment check, #3086
         Given the node map
             """

features/guidance/turn-angles.feature

@@ -848,6 +848,7 @@ Feature: Simple Turns
             | h,a       | Heide,Perle,Perle   | depart,turn left,arrive  | true:16;true:90 true:195 true:270 true:345;true:90    |
 
     #http://www.openstreetmap.org/#map=19/52.53293/13.32956
+    # adjusted ways to reflect the case geometry for 2/3/2018
     Scenario: Curved Exit from Curved Road
         Given the node map
             """
@@ -874,16 +875,16 @@ Feature: Simple Turns
 
         And the ways
             | nodes  | name    | oneway | lanes | highway     |
-            | abcd   | Siemens | no     | 5     | secondary   |
-            | defg   | Erna    | no     | 3     | secondary   |
+            | ab     | Siemens | no     | 5     | secondary   |
+            | bcdefg | Erna    | no     | 3     | secondary   |
             | dhij   | Siemens | no     |       | residential |
 
         When I route I should get
-            | waypoints | route                   | turns                               |
-            | a,j       | Siemens,Siemens,Siemens | depart,continue slight right,arrive |
-            | a,g       | Siemens,Erna            | depart,arrive                       |
-            | g,j       | Erna,Siemens,Siemens    | depart,turn left,arrive             |
-            | g,a       | Erna,Siemens            | depart,arrive                       |
+            | waypoints | route                   | turns                           |
+            | a,j       | Siemens,Siemens,Siemens | depart,turn slight right,arrive |
+            | a,g       | Siemens,Erna            | depart,arrive                   |
+            | g,j       | Erna,Siemens,Siemens    | depart,turn left,arrive         |
+            | g,a       | Erna,Siemens            | depart,arrive                   |
 
      #http://www.openstreetmap.org/#map=19/52.51303/13.32170
      Scenario: Ernst Reuter Platz

features/guidance/turn-lanes.feature

@@ -301,7 +301,7 @@ Feature: Turn Lane Guidance
             | e,l       | road,cross,cross  | depart,turn right,arrive     | ,none:false straight:false straight;right:true,                               |
             | i,h       | cross,road,road   | depart,turn right,arrive     | ,,                                                                            |
             | i,j       | cross,cross       | depart,arrive                | ;;left:false straight:true,                                                   |
-            | i,l       | cross,cross,cross | depart,continue uturn,arrive | ;,left:true straight:false;left:true straight:false;left:false straight:true, |
+            | i,l       | cross,cross,cross | depart,continue uturn,arrive | ,left:true straight:false;left:true straight:false;left:true straight:false;left:false straight:true, |
 
     @partition-lanes
     Scenario: Turn Lanes at Segregated Road
@@ -614,8 +614,9 @@ Feature: Turn Lane Guidance
                  | |
                  | |
                  b d
-            h     c
-             ' -- g - - f
+            h-----c
+                  | `-f
+                  g
             """
 
         And the ways
@@ -936,48 +937,52 @@ Feature: Turn Lane Guidance
     Scenario: Partitioned turn, Slight Curve - maxspeed
         Given the node map
             """
-                f   e
-                |   |
-                |   |
-                |   c
-            a - b ' |
-                g   d
+                    f   e
+                    |   |
+                i   |   |
+                |   |   c
+            h - a - b ' |
+                j   g   d
             """
 
         And the ways
             | nodes | name  | highway | oneway | turn:lanes:forward | maxspeed |
+            | ha    | road  | primary | yes    |                    | 1        |
             | ab    | road  | primary | yes    | left\|right        | 1        |
             | bc    | cross | primary | yes    |                    | 1        |
             | fbg   | cross | primary | yes    |                    | 1        |
             | dce   | cross | primary | yes    |                    | 1        |
+            | iaj   | kross | primary | no     |                    | 1        |
 
         When I route I should get
             | waypoints | route            | turns                          | lanes                                         | locations |
-            | a,g       | road,cross,cross | depart,turn right,arrive       | ,left:false right:true,                       | a,b,g     |
-            | a,e       | road,cross,cross | depart,end of road left,arrive | ;left:true right:false,left:true right:false, | a,c,e     |
+            | h,g       | road,cross,cross | depart,turn right,arrive       | ;,left:false right:true,                       | h,b,g     |
+            | h,e       | road,cross,cross | depart,end of road left,arrive | ;,left:true right:false;left:true right:false, | h,b,e     |
 
     Scenario: Partitioned turn, Slight Curve
         Given the node map
             """
-                f   e
-                |   |
-                |   |
-                |   c
-            a - b ' |
-                g   d
+                    f   e
+                    |   |
+                i   |   |
+                |   |   c
+            h - a - b ' |
+                j   g   d
             """
 
         And the ways
             | nodes | name  | highway | oneway | turn:lanes:forward |
+            | ha    | road  | primary | yes    |                    |
             | ab    | road  | primary | yes    | left\|right        |
             | bc    | cross | primary | yes    |                    |
             | fbg   | cross | primary | yes    |                    |
             | dce   | cross | primary | yes    |                    |
+            | iaj   | kross | primary | no     |                    |
 
         When I route I should get
-            | waypoints | route            | turns                          | lanes                                         | locations |
-            | a,g       | road,cross,cross | depart,turn right,arrive       | ,left:false right:true,                       | a,b,g     |
-            | a,e       | road,cross,cross | depart,end of road left,arrive | ;left:true right:false,left:true right:false, | a,c,e     |
+            | waypoints | route            | turns                          | lanes                                          | locations |
+            | h,g       | road,cross,cross | depart,turn right,arrive       | ;,left:false right:true,                       | h,b,g     |
+            | h,e       | road,cross,cross | depart,end of road left,arrive | ;,left:true right:false;left:true right:false, | h,b,e     |
 
     Scenario: Lane Parsing Issue #2694
         Given the node map
@@ -1243,4 +1248,4 @@ Feature: Turn Lane Guidance
 
         When I route I should get
             | waypoints | route             | turns                        | lanes                                                                                           | locations |
-            | a,f       | road1,road1,road1 | depart,continue uturn,arrive | ;left:false straight:true straight;right:false,left:true straight:false straight;right:false;;, | a,d,f     |
+            | a,f       | road1,road1,road1 | depart,continue uturn,arrive | ,;left:true straight:false straight;right:false;;, | a,c,f     |

features/guidance/turn.feature

@@ -899,9 +899,9 @@ Feature: Simple Turns
             """
 
         And the ways
-            | nodes | highway     | name |
-            | abc   | primary     | road |
-            | bd    | residential | in   |
+            | nodes | highway     | name | lanes |
+            | abc   | primary     | road |     3 |
+            | bd    | residential | in   |     1 |
 
         When I route I should get
             | waypoints | turns                   | route        |
@@ -964,15 +964,15 @@ Feature: Simple Turns
         Given the node map
             """
                   g
-
-                  f     y
-            i
-            j k a   b   x
-                  e   c
-                    d
-
+                  |
+               _--f-----y
+            i-'   |
+            j-k-a]|[b---x
+                  e  'c
+                  |'d'
+                  |
                   h
-
+                  |
                   q
             """
 
@@ -1373,6 +1373,36 @@ Feature: Simple Turns
             | a,d       | ab,bcd,bcd   | depart,fork slight right,arrive |
             | a,g       | ab,befg,befg | depart,fork slight left,arrive  |
 
+	@routing @car
+    Scenario: No turn instruction when turning from unnamed onto unnamed
+        Given the node map
+            """
+            a
+            |
+            |
+            |
+            |
+            b----------------c
+            |
+            |
+            |
+            |
+            |
+            |
+            d
+            """
+
+        And the ways
+            | nodes | highway     | name | ref   |
+            | ab    | trunk_link  |      |       |
+            | db    | secondary   |      | L 460 |
+            | bc    | secondary   |      |       |
+
+        When I route I should get
+            | from | to | route | ref          | turns                    |
+            | d    | c  | ,,    | L 460,,      | depart,turn right,arrive |
+            | c    | d  | ,,    | ,L 460,L 460 | depart,turn left,arrive  |
+
     # https://www.openstreetmap.org/#map=18/52.25130/10.42545
     Scenario: Turn for roads with no name, ref changes
         Given the node map
@@ -1404,21 +1434,21 @@ Feature: Simple Turns
     Scenario: Turn for roads with no name, ref changes
         Given the node map
             """
-              x
-              .
-              .
-              d
-             . .
-            .   .
-           .     .
-     e. . t . c . p. .f
-           .     .
-            .   .
-             . .
-              b
-              .
-              .
-              a
+                     x
+                     .
+                     .
+                     d
+                    . .
+                   .   .
+                  .     .
+            e. . t . c . p. .f
+                  .     .
+                   .   .
+                    . .
+                     b
+                     .
+                     .
+                     a
             """
 
         And the ways
@@ -1430,6 +1460,6 @@ Feature: Simple Turns
             | etcpf | primary     | B 1  |               | no     |
 
        When I route I should get
-            | waypoints | route     | turns                                    |
-            | e,x       | ,,,       | depart,turn sharp left,turn right,arrive |
-            | f,a       | ,,        | depart,turn left,arrive                  |
+            | waypoints | route | turns                   |
+            | e,x       | ,,    | depart,turn left,arrive |
+            | f,a       | ,,    | depart,turn left,arrive |

features/lib/osrm_loader.js

@@ -47,7 +47,7 @@ class OSRMBaseLoader{
           if (err) {
             if (retryCount < 10) {
               retryCount++;
-              setTimeout(() => { tryConnect(this.scope.OSRM_PORT, retry); }, 10);
+              setTimeout(() => { tryConnect(this.scope.OSRM_IP, this.scope.OSRM_PORT, retry); }, 10);
             } else {
               callback(new Error("Could not connect to osrm-routed after ten retries."));
             }
@@ -58,7 +58,7 @@ class OSRMBaseLoader{
           }
         };
 
-        tryConnect(this.scope.OSRM_PORT, retry);
+        tryConnect(this.scope.OSRM_IP, this.scope.OSRM_PORT, retry);
     }
 };
 
@@ -77,7 +77,7 @@ class OSRMDirectLoader extends OSRMBaseLoader {
     osrmUp (callback) {
         if (this.osrmIsRunning()) return callback(new Error("osrm-routed already running!"));
 
-        const command_arguments = util.format('%s -p %d -a %s', this.inputFile, this.scope.OSRM_PORT, this.scope.ROUTING_ALGORITHM);
+        const command_arguments = util.format('%s -p %d -i %s -a %s', this.inputFile, this.scope.OSRM_PORT, this.scope.OSRM_IP, this.scope.ROUTING_ALGORITHM);
         this.child = this.scope.runBin('osrm-routed', command_arguments, this.scope.environment, (err) => {
             if (err && err.signal !== 'SIGINT') {
                 this.child = null;
@@ -107,7 +107,8 @@ class OSRMDatastoreLoader extends OSRMBaseLoader {
     }
 
     loadData (callback) {
-        this.scope.runBin('osrm-datastore', this.inputFile, this.scope.environment, (err) => {
+        const command_arguments = util.format('--dataset-name=%s %s', this.scope.DATASET_NAME, this.inputFile);
+        this.scope.runBin('osrm-datastore', command_arguments, this.scope.environment, (err) => {
             if (err) return callback(new Error('*** osrm-datastore exited with ' + err.code + ': ' + err));
             callback();
         });
@@ -116,7 +117,7 @@ class OSRMDatastoreLoader extends OSRMBaseLoader {
     osrmUp (callback) {
         if (this.osrmIsRunning()) return callback();
 
-        const command_arguments = util.format('--shared-memory=1 -p %d -a %s', this.scope.OSRM_PORT, this.scope.ROUTING_ALGORITHM);
+        const command_arguments = util.format('--dataset-name=%s -s -i %s -p %d -a %s', this.scope.DATASET_NAME, this.scope.OSRM_IP, this.scope.OSRM_PORT, this.scope.ROUTING_ALGORITHM);
         this.child = this.scope.runBin('osrm-routed', command_arguments, this.scope.environment, (err) => {
             if (err && err.signal !== 'SIGINT') {
                 this.child = null;

features/lib/try_connect.js

@@ -3,8 +3,8 @@
 const net = require('net');
 const Timeout = require('node-timeout');
 
-module.exports = function tryConnect(port, callback) {
-  net.connect({ port: port, host: '127.0.0.1' })
+module.exports = function tryConnect(host, port, callback) {
+  net.connect({ port: port, host: host })
     .on('connect', () => { callback(); })
     .on('error', () => {
         callback(new Error('Could not connect.'));

features/options/datastore/datastore.feature

@@ -0,0 +1,44 @@
+@datastore @options @help
+Feature: osrm-datastore command line options
+
+    Background:
+        Given the profile "testbot"
+        And the node map
+            """
+            a b
+            """
+        And the ways
+            | nodes |
+            | ab    |
+        And the data has been contracted
+
+    Scenario: osrm-datastore - Help should be shown when no options are passed
+        When I try to run "osrm-datastore --dataset-name test_dataset_42 {processed_file}"
+        Then it should exit successfully
+        When I try to run "osrm-datastore --list"
+        Then it should exit successfully
+        And stdout should contain "test_dataset_42/static"
+        And stdout should contain "test_dataset_42/updatable"
+
+    Scenario: osrm-datastore - Only metric update should work
+        Given the speed file
+        """
+        0,1,50
+        """
+        And the data has been extracted
+        When I try to run "osrm-datastore {processed_file} --dataset-name cucumber/only_metric_test"
+        Then it should exit successfully
+        When I try to run "osrm-customize --segment-speed-file {speeds_file} {processed_file}"
+        Then it should exit successfully
+        When I try to run "osrm-datastore {processed_file} --dataset-name cucumber/only_metric_test --only-metric"
+        Then it should exit successfully
+
+    Scenario: osrm-datastore - Displaying help should work
+        When I try to run "osrm-datastore {processed_file} --help"
+        Then it should exit successfully
+
+    Scenario: osrm-datastore - Errors on invalid path
+        When I try to run "osrm-datastore invalid_path.osrm"
+        Then stderr should contain "[error] Config contains invalid file paths."
+        And stderr should contain "Missing/Broken"
+        And it should exit with an error

features/options/extract/lua.feature

@@ -129,8 +129,12 @@ Feature: osrm-extract lua ways:get_nodes()
         """
         functions = require('testbot')
 
+        functions.process_node = function(profile, node, result, relations)
+           print ('node ' .. tostring(node:get_location_tag('answer')))
+        end
+
         functions.process_way = function(profile, way, result, relations)
-           print ('answer ' .. tostring(way:get_location_tag('answer')))
+           print ('way ' .. tostring(way:get_location_tag('answer')))
            result.forward_mode = mode.driving
            result.forward_speed = 1
         end
@@ -148,4 +152,5 @@ Feature: osrm-extract lua ways:get_nodes()
 
         When I run "osrm-extract --profile {profile_file} {osm_file} --location-dependent-data test/data/regions/null-island.geojson"
         Then it should exit successfully
-        And stdout should contain "answer 42"
+        And stdout should contain "node 42"
+        And stdout should contain "way 42"

features/options/extract/turn_function.feature

@@ -0,0 +1,182 @@
+@routing @testbot @turn_function
+Feature: Turn Function Information
+
+
+    Background:
+        Given the profile file
+        """
+        functions = require('car')
+
+        function test_setup()
+          profile = functions.setup()
+          profile.highway_turn_classification = {
+              ['motorway'] = 4,
+              ['motorway_link'] = 4,
+              ['trunk'] = 4,
+              ['trunk_link'] = 4,
+              ['primary'] = 4,
+              ['primary_link'] = 4,
+              ['secondary'] = 3,
+              ['secondary_link'] = 3,
+              ['tertiary'] = 2,
+              ['tertiary_link'] = 2,
+              ['residential'] = 1,
+              ['living_street'] = 1,
+          }
+
+          profile.access_turn_classification = {
+              ['discouraged'] = 1;
+              ['permissive'] = 1;
+              ['private'] = 1;
+              ['customers'] = 1;
+              ['dismount'] = 1;
+          }
+          return profile
+        end
+
+        function turn_leg_string (leg)
+          return 'speed: ' .. tostring(leg.speed)
+             .. ', is_incoming: ' .. tostring(leg.is_incoming)
+             .. ', is_outgoing: ' .. tostring(leg.is_outgoing)
+             .. ', highway_turn_classification: ' .. tostring(leg.highway_turn_classification)
+             .. ', access_turn_classification: ' .. tostring(leg.access_turn_classification)
+             .. ', priority_class: ' .. tostring(leg.priority_class)
+        end
+
+        function print_turn (profile, turn)
+          print ('source_restricted ' .. string.format("%s", tostring(turn.source_restricted)))
+          print ('source_is_motorway ' .. string.format("%s", tostring(turn.source_is_motorway)))
+          print ('source_is_link ' .. string.format("%s", tostring(turn.source_is_link)))
+          print ('source_number_of_lanes ' .. string.format("%s", tostring(turn.source_number_of_lanes)))
+          print ('source_highway_turn_classification ' .. string.format("%s", tostring(turn.source_highway_turn_classification)))
+          print ('source_access_turn_classification ' .. string.format("%s", tostring(turn.source_access_turn_classification)))
+          print ('source_speed ' .. string.format("%s", tostring(turn.source_speed)))
+          print ('source_priority_class ' .. string.format("%s", tostring(turn.source_priority_class)))
+          print ('source_mode ' .. string.format("%s", tostring(turn.source_mode)))
+
+          print ('target_restricted ' .. string.format("%s", tostring(turn.target_restricted)))
+          print ('target_is_motorway ' .. string.format("%s", tostring(turn.target_is_motorway)))
+          print ('target_is_link ' .. string.format("%s", tostring(turn.target_is_link)))
+          print ('target_number_of_lanes ' .. string.format("%s", tostring(turn.target_number_of_lanes)))
+          print ('target_highway_turn_classification ' .. string.format("%s", tostring(turn.target_highway_turn_classification)))
+          print ('target_access_turn_classification ' .. string.format("%s", tostring(turn.target_access_turn_classification)))
+          print ('target_speed ' .. string.format("%s", tostring(turn.target_speed)))
+          print ('target_priority_class ' .. string.format("%s", tostring(turn.target_priority_class)))
+          print ('target_mode ' .. string.format("%s", tostring(turn.target_mode)))
+
+          print ('number_of_roads ' .. string.format("%s", tostring(turn.number_of_roads)))
+          if not turn.is_u_turn then
+          for roadCount, road in ipairs(turn.roads_on_the_right) do
+              print('roads_on_the_right [' .. tostring(roadCount) .. '] ' .. turn_leg_string(road))
+            end
+
+            for roadCount, road in ipairs(turn.roads_on_the_left) do
+              print('roads_on_the_left [' .. tostring(roadCount) .. '] ' .. turn_leg_string(road))
+            end
+          end
+        end
+
+        return {
+            setup = test_setup,
+            process_way = functions.process_way,
+            process_node = functions.process_node,
+            process_turn = print_turn
+        }
+        """
+
+    Scenario: Turns should have correct information of source and target
+        Given the node map
+            """
+
+            a b c
+
+            """
+        And the ways
+            | nodes | highway  |
+            | ab    | motorway |
+            | bc    | motorway |
+        And the data has been saved to disk
+
+        When I run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit successfully
+        And stdout should contain "source_is_motorway true"
+        And stdout should contain "target_is_motorway true"
+        And stdout should contain "source_is_link false"
+        And stdout should contain "source_priority_class 0"
+        And stdout should contain "target_is_motorway true"
+        And stdout should contain "target_is_link false"
+        And stdout should contain "target_priority_class 0"
+
+
+    Scenario: Turns should detect when turn is leaving highway
+        Given the node map
+            """
+
+            a b c
+
+            """
+        And the ways
+            | nodes | highway       | lanes |
+            | ab    | motorway      | 3     |
+            | bc    | motorway_link |       |
+
+        And the data has been saved to disk
+
+        When I run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit successfully
+        And stdout should contain "source_is_motorway true"
+        And stdout should contain "source_is_link false"
+        And stdout should contain "source_number_of_lanes 3"
+        And stdout should contain "target_is_motorway false"
+        And stdout should contain "target_is_link true"
+        And stdout should contain "target_number_of_lanes 0"
+        And stdout should contain "number_of_roads 2"
+
+    Scenario: Turns should have correct information of other roads at intersection I
+        Given the node map
+            """
+               d
+               ^
+               |
+            a->b->c
+            """
+        And the ways
+            | nodes | highway     | oneway |
+            | ab    | primary     | yes    |
+            | bc    | motorway    | yes    |
+            | bd    | residential | yes    |
+        And the data has been saved to disk
+
+        When I run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit successfully
+        And stdout should contain "number_of_roads 3"
+        And stdout should contain "source_priority_class 4"
+        And stdout should contain "target_priority_class 0"
+        And stdout should contain "target_priority_class 10"
+        # turning abd, give information about bc
+        And stdout should contain /roads_on_the_right \[1\] speed: [0-9]+, is_incoming: false, is_outgoing: true, highway_turn_classification: 4, access_turn_classification: 0/
+        # turning abc, give information about bd
+        And stdout should contain /roads_on_the_left \[1\] speed: [0-9]+, is_incoming: false, is_outgoing: true, highway_turn_classification: 1, access_turn_classification: 0/
+
+    Scenario: Turns should have correct information of other roads at intersection II
+        Given the node map
+            """
+               d
+               |
+               v
+            a->b->c
+            """
+        And the ways
+            | nodes | highway      | oneway | access      |
+            | ab    | secondary    | yes    |             |
+            | bc    | motorway     | yes    |             |
+            | db    | unclassified | yes    | discouraged |
+        And the data has been saved to disk
+
+        When I run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit successfully
+        And stdout should contain "number_of_roads 3"
+        # turning dbc, give information about about ab
+        And stdout should contain /roads_on_the_right \[1\] speed: [0-9]+, is_incoming: true, is_outgoing: false, highway_turn_classification: 3, access_turn_classification: 0/
+        # turning abc, give information about about db
+        And stdout should contain /roads_on_the_left \[1\] speed: [0-9]+, is_incoming: true, is_outgoing: false, highway_turn_classification: 0, access_turn_classification: 1/

features/step_definitions/data.js

@@ -185,31 +185,34 @@ module.exports = function () {
 
         let q = d3.queue();
 
-        let addRelation = (row, cb) => {
+        let addRelation = (headers, row, cb) => {
             let relation = new OSM.Relation(this.makeOSMId(), this.OSM_USER, this.OSM_TIMESTAMP, this.OSM_UID);
 
 
             var name = null;
-            for (let key in row) {
+            for (let index in row) {
+
+                var key = headers[index];
+                var value = row[index];
                 let isNode = key.match(/^node:?(.*)/),
                     isWay = key.match(/^way:?(.*)/),
                     isRelation = key.match(/^relation:?(.*)/),
                     isColonSeparated = key.match(/^(.*):(.*)/);
                 if (isNode) {
-                    row[key].split(',').map(function(v) { return v.trim(); }).forEach((nodeName) => {
+                    value.split(',').map(function(v) { return v.trim(); }).forEach((nodeName) => {
                         if (nodeName.length !== 1) throw new Error(util.format('*** invalid relation node member "%s"', nodeName));
                         let node = this.findNodeByName(nodeName);
                         if (!node) throw new Error(util.format('*** unknown relation node member "%s"', nodeName));
                         relation.addMember('node', node.id, isNode[1]);
                     });
                 } else if (isWay) {
-                    row[key].split(',').map(function(v) { return v.trim(); }).forEach((wayName) => {
+                    value.split(',').map(function(v) { return v.trim(); }).forEach((wayName) => {
                         let way = this.findWayByName(wayName);
                         if (!way) throw new Error(util.format('*** unknown relation way member "%s"', wayName));
                         relation.addMember('way', way.id, isWay[1]);
                     });
                 } else if (isRelation) {
-                    row[key].split(',').map(function(v) { return v.trim(); }).forEach((relName) => {
+                    value.split(',').map(function(v) { return v.trim(); }).forEach((relName) => {
                         let otherrelation = this.findRelationByName(relName);
                         if (!otherrelation) throw new Error(util.format('*** unknown relation relation member "%s"', relName));
                         relation.addMember('relation', otherrelation.id, isRelation[1]);
@@ -217,8 +220,8 @@ module.exports = function () {
                 } else if (isColonSeparated && isColonSeparated[1] !== 'restriction') {
                     throw new Error(util.format('*** unknown relation member type "%s:%s", must be either "node" or "way"', isColonSeparated[1], isColonSeparated[2]));
                 } else {
-                    relation.addTag(key, row[key]);
-                    if (key.match(/name/)) name = row[key];
+                    relation.addTag(key, value);
+                    if (key.match(/name/)) name = value;
                 }
             }
             relation.uid = this.OSM_UID;
@@ -233,7 +236,8 @@ module.exports = function () {
             cb();
         };
 
-        table.hashes().forEach((row) => q.defer(addRelation, row));
+        var headers = table.raw()[0];
+        table.rows().forEach((row) => q.defer(addRelation, headers, row));
 
         q.awaitAll(callback);
     });

features/step_definitions/distance_matrix.js

@@ -1,74 +1,88 @@
 var util = require('util');
 
 module.exports = function () {
-    this.When(/^I request a travel time matrix I should get$/, (table, callback) => {
-        var NO_ROUTE = 2147483647;    // MAX_INT
+    const durationsRegex = new RegExp(/^I request a travel time matrix I should get$/);
+    const distancesRegex = new RegExp(/^I request a travel distance matrix I should get$/);
 
-        var tableRows = table.raw();
+    const DURATIONS_NO_ROUTE = 2147483647;     // MAX_INT
+    const DISTANCES_NO_ROUTE = 3.40282e+38;    // MAX_FLOAT
 
-        if (tableRows[0][0] !== '') throw new Error('*** Top-left cell of matrix table must be empty');
+    this.When(durationsRegex, function(table, callback) {tableParse.call(this, table, DURATIONS_NO_ROUTE, 'durations', callback);}.bind(this));
+    this.When(distancesRegex, function(table, callback) {tableParse.call(this, table, DISTANCES_NO_ROUTE, 'distances', callback);}.bind(this));
+};
 
-        var waypoints = [],
-            columnHeaders = tableRows[0].slice(1),
-            rowHeaders = tableRows.map((h) => h[0]).slice(1),
-            symmetric = columnHeaders.length == rowHeaders.length && columnHeaders.every((ele, i) => ele === rowHeaders[i]);
+const durationsParse = function(v) { return isNaN(parseInt(v)); };
+const distancesParse = function(v) { return isNaN(parseFloat(v)); };
 
-        if (symmetric) {
-            columnHeaders.forEach((nodeName) => {
-                var node = this.findNodeByName(nodeName);
-                if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
-                waypoints.push({ coord: node, type: 'loc' });
+function tableParse(table, noRoute, annotation, callback) {
+
+    const parse = annotation == 'distances' ? distancesParse : durationsParse;
+    const params = this.queryParams;
+    params.annotations = annotation == 'distances' ? 'distance' : 'duration';
+
+    var tableRows = table.raw();
+
+    if (tableRows[0][0] !== '') throw new Error('*** Top-left cell of matrix table must be empty');
+
+    var waypoints = [],
+        columnHeaders = tableRows[0].slice(1),
+        rowHeaders = tableRows.map((h) => h[0]).slice(1),
+        symmetric = columnHeaders.length == rowHeaders.length && columnHeaders.every((ele, i) => ele === rowHeaders[i]);
+
+    if (symmetric) {
+        columnHeaders.forEach((nodeName) => {
+            var node = this.findNodeByName(nodeName);
+            if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
+            waypoints.push({ coord: node, type: 'loc' });
+        });
+    } else {
+        columnHeaders.forEach((nodeName) => {
+            var node = this.findNodeByName(nodeName);
+            if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
+            waypoints.push({ coord: node, type: 'dst' });
+        });
+        rowHeaders.forEach((nodeName) => {
+            var node = this.findNodeByName(nodeName);
+            if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
+            waypoints.push({ coord: node, type: 'src' });
+        });
+    }
+
+    var actual = [];
+    actual.push(table.headers);
+
+    this.reprocessAndLoadData((e) => {
+        if (e) return callback(e);
+        // compute matrix
+
+        this.requestTable(waypoints, params, (err, response) => {
+            if (err) return callback(err);
+            if (!response.body.length) return callback(new Error('Invalid response body'));
+
+            var json = JSON.parse(response.body);
+
+            var result = json[annotation].map(row => {
+                var hashes = {};
+                row.forEach((v, i) => { hashes[tableRows[0][i+1]] = parse(v) ? '' : v; });
+                return hashes;
             });
-        } else {
-            columnHeaders.forEach((nodeName) => {
-                var node = this.findNodeByName(nodeName);
-                if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
-                waypoints.push({ coord: node, type: 'dst' });
-            });
-            rowHeaders.forEach((nodeName) => {
-                var node = this.findNodeByName(nodeName);
-                if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
-                waypoints.push({ coord: node, type: 'src' });
-            });
-        }
 
-        var actual = [];
-        actual.push(table.headers);
-
-        this.reprocessAndLoadData((e) => {
-            if (e) return callback(e);
-            // compute matrix
-            var params = this.queryParams;
-
-            this.requestTable(waypoints, params, (err, response) => {
-                if (err) return callback(err);
-                if (!response.body.length) return callback(new Error('Invalid response body'));
-
-                var json = JSON.parse(response.body);
-
-                var result = json['durations'].map(row => {
-                    var hashes = {};
-                    row.forEach((v, i) => { hashes[tableRows[0][i+1]] = isNaN(parseInt(v)) ? '' : v; });
-                    return hashes;
-                });
-
-                var testRow = (row, ri, cb) => {
-                    for (var k in result[ri]) {
-                        if (this.FuzzyMatch.match(result[ri][k], row[k])) {
-                            result[ri][k] = row[k];
-                        } else if (row[k] === '' && result[ri][k] === NO_ROUTE) {
-                            result[ri][k] = '';
-                        } else {
-                            result[ri][k] = result[ri][k].toString();
-                        }
+            var testRow = (row, ri, cb) => {
+                for (var k in result[ri]) {
+                    if (this.FuzzyMatch.match(result[ri][k], row[k])) {
+                        result[ri][k] = row[k];
+                    } else if (row[k] === '' && result[ri][k] === noRoute) {
+                        result[ri][k] = '';
+                    } else {
+                        result[ri][k] = result[ri][k].toString();
                     }
+                }
 
-                    result[ri][''] = row[''];
-                    cb(null, result[ri]);
-                };
+                result[ri][''] = row[''];
+                cb(null, result[ri]);
+            };
 
-                this.processRowsAndDiff(table, testRow, callback);
-            });
+            this.processRowsAndDiff(table, testRow, callback);
         });
     });
-};
+}

features/step_definitions/matching.js

@@ -74,7 +74,7 @@ module.exports = function () {
 
                         if (headers.has('turns')) {
                             if (json.matchings.length != 1) throw new Error('*** Checking turns only supported for matchings with one subtrace');
-                            turns = this.turnList(json.matchings[0].instructions);
+                            turns = this.turnList(json.matchings[0]);
                         }
 
                         if (headers.has('route')) {

features/support/cache.js

@@ -36,8 +36,8 @@ module.exports = function() {
                 // shorten uri to be realtive to 'features/'
                 let featurePath = path.relative(path.resolve('./features'), uri);
                 // bicycle/bollards/{HASH}/
-                let featureID = path.join(featurePath, hash);                    
-                
+                let featureID = path.join(featurePath, hash);
+
                 let featureCacheDirectory = this.getFeatureCacheDirectory(featureID);
                 let featureProcessedCacheDirectory = this.getFeatureProcessedCacheDirectory(featureCacheDirectory, this.osrmHash);
                 this.featureIDs[uri] = featureID;
@@ -115,6 +115,7 @@ module.exports = function() {
             this.OSRM_EXTRACT_PATH,
             this.OSRM_CONTRACT_PATH,
             this.LIB_OSRM_EXTRACT_PATH,
+            this.LIB_OSRM_GUIDANCE_PATH,
             this.LIB_OSRM_CONTRACT_PATH
         ];
 

features/support/data_classes.js

@@ -21,7 +21,8 @@ module.exports = {
                 matchRe = want.match(/^\/(.*)\/$/),
                 // we use this for matching before/after bearing
                 matchBearingListAbs = want.match(/^((\d+)->(\d+))(,(\d+)->(\d+))*\s+\+\-(.+)$/),
-                matchIntersectionListAbs = want.match(/^(((((true|false):\d+)\s{0,1})+,{0,1})+;{0,1})+\s+\+\-(.+)$/);
+                matchIntersectionListAbs = want.match(/^(((((true|false):\d+)\s{0,1})+,{0,1})+;{0,1})+\s+\+\-(.+)$/),
+                matchRangeNumbers = want.match(/\d+\+\-\d+/);
 
             function inRange(margin, got, want) {
                 var fromR = parseFloat(want) - margin,
@@ -105,6 +106,11 @@ module.exports = {
                 return inRange(margin, got, matchAbs[1]);
             } else if (matchRe) {               // regex: /a,b,.*/
                 return got.match(matchRe[1]);
+            } else if (matchRangeNumbers) {
+                let real_want_and_margin = want.split('+-'),
+                    margin = parseFloat(real_want_and_margin[1].trim()),
+                    real_want = parseFloat(real_want_and_margin[0].trim());
+                return inRange(margin, got, real_want);
             } else {
                 return false;
             }

features/support/env.js

@@ -27,6 +27,7 @@ module.exports = function () {
             return callback(new Error('*** '+stxxl_config+ 'does not exist'));
         }
 
+        this.DATASET_NAME = 'cucumber';
         this.PLATFORM_WINDOWS = process.platform.match(/^win.*/);
         this.DEFAULT_ENVIRONMENT = Object.assign({STXXLCFG: stxxl_config}, process.env);
         this.DEFAULT_PROFILE = 'bicycle';
@@ -43,8 +44,9 @@ module.exports = function () {
         this.TIMEZONE_NAMES = this.PLATFORM_WINDOWS ? 'win' : 'iana';
 
         this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
-        this.HOST = 'http://127.0.0.1:' + this.OSRM_PORT;
-        
+        this.OSRM_IP = process.env.OSRM_IP || '127.0.0.1';
+        this.HOST = `http://${this.OSRM_IP}:${this.OSRM_PORT}`;
+
         this.OSRM_PROFILE = process.env.OSRM_PROFILE;
 
         if (this.PLATFORM_WINDOWS) {
@@ -72,6 +74,7 @@ module.exports = function () {
         this.OSRM_CONTRACT_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-contract', this.EXE));
         this.OSRM_ROUTED_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-routed', this.EXE));
         this.LIB_OSRM_EXTRACT_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_extract'),
+        this.LIB_OSRM_GUIDANCE_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_guidance'),
         this.LIB_OSRM_CONTRACT_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_contract'),
         this.LIB_OSRM_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm');
 
@@ -92,7 +95,7 @@ module.exports = function () {
     };
 
     this.verifyOSRMIsNotRunning = (callback) => {
-        tryConnect(this.OSRM_PORT, (err) => {
+        tryConnect(this.OSRM_IP, this.OSRM_PORT, (err) => {
             if (!err) return callback(new Error('*** osrm-routed is already running.'));
             else callback();
         });

features/support/hooks.js

@@ -50,6 +50,8 @@ module.exports = function () {
             .defer(mkdirp, logDir)
             .defer(rimraf, this.scenarioLogFile)
             .awaitAll(callback);
+        // uncomment to get path to logfile
+        // console.log('  Writing logging output to ' + this.scenarioLogFile);
     });
 
     this.After((scenario, callback) => {

features/support/route.js

@@ -199,14 +199,26 @@ module.exports = function () {
 
         var merged = {};
         instructions.legs.map(l => {
-            Object.keys(l.annotation).forEach(a => {
+            Object.keys(l.annotation).filter(a => !a.match(/metadata/)).forEach(a => {
                 if (!merged[a]) merged[a] = [];
                 merged[a].push(l.annotation[a].join(':'));
             });
+            if (l.annotation.metadata) {
+                merged.metadata = {};
+                Object.keys(l.annotation.metadata).forEach(a => {
+                    if (!merged.metadata[a]) merged.metadata[a] = [];
+                    merged.metadata[a].push(l.annotation.metadata[a].join(':'));
+                });
+            }
         });
-        Object.keys(merged).map(a => {
+        Object.keys(merged).filter(k => !k.match(/metadata/)).map(a => {
             merged[a] = merged[a].join(',');
         });
+        if (merged.metadata) {
+            Object.keys(merged.metadata).map(a => {
+                merged.metadata[a] = merged.metadata[a].join(',');
+            });
+        }
         return merged;
     };
 

features/support/shared_steps.js

@@ -158,7 +158,8 @@ module.exports = function () {
                         // if header matches 'a:*', parse out the values for *
                         // and return in that header
                         headers.forEach((k) => {
-                            let whitelist = ['duration', 'distance', 'datasources', 'nodes', 'weight', 'speed'];
+                            let whitelist = ['duration', 'distance', 'datasources', 'nodes', 'weight', 'speed' ];
+                            let metadata_whitelist = [ 'datasource_names' ];
                             if (k.match(/^a:/)) {
                                 let a_type = k.slice(2);
                                 if (whitelist.indexOf(a_type) == -1)
@@ -166,6 +167,13 @@ module.exports = function () {
                                 if (annotation && !annotation[a_type])
                                     return cb(new Error('Annotation not found in response', a_type));
                                 got[k] = annotation && annotation[a_type] || '';
+                            } else if (k.match(/^am:/)) {
+                                let a_type = k.slice(3);
+                                if (metadata_whitelist.indexOf(a_type) == -1)
+                                    return cb(new Error('Unrecognized annotation field', a_type));
+                                if (annotation && (!annotation.metadata || !annotation.metadata[a_type]))
+                                    return cb(new Error('Annotation not found in response', a_type));
+                                got[k] = (annotation && annotation.metadata && annotation.metadata[a_type]) || '';
                             }
                         });
 

features/testbot/alternative.feature

@@ -4,6 +4,14 @@ Feature: Alternative route
     Background:
         Given the profile "testbot"
         And a grid size of 200 meters
+        # Force data preparation to single-threaded to ensure consistent
+        # results for alternative generation during tests (alternative
+        # finding is highly sensitive to graph shape, which is in turn
+        # affected by parallelism during generation)
+        And the contract extra arguments "--threads 1"
+        And the extract extra arguments "--threads 1"
+        And the customize extra arguments "--threads 1"
+        And the partition extra arguments "--threads 1"
 
         And the node map
             """

features/testbot/alternative_loop.feature

@@ -4,6 +4,14 @@ Feature: Alternative route
     Background:
         Given the profile "testbot"
         Given a grid size of 200 meters
+        # Force data preparation to single-threaded to ensure consistent
+        # results for alternative generation during tests (alternative
+        # finding is highly sensitive to graph shape, which is in turn
+        # affected by parallelism during generation)
+        And the contract extra arguments "--threads 1"
+        And the extract extra arguments "--threads 1"
+        And the customize extra arguments "--threads 1"
+        And the partition extra arguments "--threads 1"
 
     Scenario: Alternative Loop Paths
         Given the node map

features/testbot/annotations.feature

@@ -11,7 +11,7 @@ Feature: Annotations
             """
 
         And the query options
-          | annotations | duration,speed,weight |
+          | annotations | duration,speed,weight,nodes |
 
         And the ways
             | nodes | highway     |
@@ -22,10 +22,10 @@ Feature: Annotations
             | lm    | residential |
 
         When I route I should get
-            | from | to | route    | a:speed     | a:weight |
-            | h    | j  | hk,jk,jk | 6.7:6.7     | 15:15    |
-            | i    | m  | il,lm,lm | 6.7:6.7     | 15:15    |
-            | j    | m  | jk,lm    | 6.7:6.7:6.7 | 15:15:15 |
+            | from | to | route    | a:speed     | a:weight | a:nodes |
+            | h    | j  | hk,jk,jk | 6.7:6.7     | 15:15    | 1:4:3   |
+            | i    | m  | il,lm,lm | 6.7:6.7     | 15:15    | 2:5:6   |
+            | j    | m  | jk,lm    | 6.7:6.7:6.7 | 15:15:15 | 3:4:5:6 |
 
 
     Scenario: There should be different forward/reverse datasources
@@ -59,3 +59,60 @@ Feature: Annotations
           | from | to | route               | a:datasources   | a:speed                 |
           | a    | i  | abcdefghi,abcdefghi | 1:0:1:0:1:0:0:0 | 50:10:50:10:50:10:10:10 |
           | i    | a  | abcdefghi,abcdefghi | 0:1:0:0:0:0:0:1 | 10:50:10:10:10:10:10:50 |
+
+    Scenario: datasource name annotations
+        Given the profile "testbot"
+
+        And the node map
+            """
+            a b c
+            """
+
+        And the ways
+            | nodes |
+            | abc   |
+
+        And the contract extra arguments "--segment-speed-file {speeds_file}"
+        And the customize extra arguments "--segment-speed-file {speeds_file}"
+
+        And the speed file
+        """
+        1,2,180,1
+        2,1,180,1
+        """
+
+        And the query options
+            | annotations | datasources |
+
+        # Note - the source names here are specific to how the tests are constructed,
+        #        so if this test is moved around (changes line number) or support code
+        #        changes how the filenames are generated, this test will need to be updated
+        When I route I should get
+            | from | to | route   | am:datasource_names                               |
+            | a    | c  | abc,abc | lua profile:63_datasource_name_annotations_speeds |
+            | c    | a  | abc,abc | lua profile:63_datasource_name_annotations_speeds |
+
+
+    Scenario: Speed annotations should handle zero segments
+        Given the profile "testbot"
+
+        Given the node map
+        """
+        a -- b --- c
+                   |
+                   d
+        """
+
+        And the ways
+          | nodes |
+          | abc   |
+          | cd    |
+
+        # This test relies on the snapping to the EBN cd to introduce a zero segment after the turn
+        And the query options
+          | annotations | speed,distance,duration,nodes |
+          | bearings    | 90,5;180,5                    |
+
+        When I route I should get
+            | from | to | route    | a:speed | a:distance            | a:duration | a:nodes |
+            | a    | c  | abc,abc  | 10:10   | 249.998641:299.931643 | 25:30      | 1:2:3   |

features/testbot/approaches.feature

@@ -74,6 +74,7 @@ Feature: Approach parameter
             | from | to | approaches        | route |
             | s    | e  | unrestricted curb | ab,bc |
 
+
     ###############
     # Oneway Test #
     ###############
@@ -226,3 +227,90 @@ Feature: Approach parameter
         When I route I should get
             | from | to | approaches        | route |
             | s    | e  | unrestricted curb | ab,bc |
+
+
+    #######################
+    # Left-side countries #
+    #######################
+
+    Scenario: [Left-hand-side] Start End same approach, option unrestricted for Start and End
+        Given the profile file "car" initialized with
+        """
+        profile.properties.left_hand_driving = true
+        """
+        And the node map
+            """
+               s        e
+            a------b------c
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches                | route |
+            | s    | e  | unrestricted unrestricted | ab,bc |
+
+    Scenario: [Left-hand-side] Start End same approach, option unrestricted for Start and curb for End
+        Given the profile file "car" initialized with
+        """
+        profile.properties.left_hand_driving = true
+        """
+        And the node map
+            """
+               s
+            a------b------c
+                       e
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches        | route    |
+            | s    | e  | unrestricted curb | ab,bc,bc |
+
+    Scenario: [Left-hand-side] Start End opposite approach, option unrestricted for Start and End
+        Given the profile file "car" initialized with
+        """
+        profile.properties.left_hand_driving = true
+        """
+        And the node map
+            """
+               s
+            a------b------c
+                        e
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches                | route |
+            | s    | e  | unrestricted unrestricted | ab,bc |
+
+    Scenario: [Left-hand-side] Start End opposite approach, option unrestricted for Start and curb for End
+        Given the profile file "car" initialized with
+        """
+        profile.properties.left_hand_driving = true
+        """
+        And the node map
+            """
+               s      e
+            a------b------c
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        When I route I should get
+            | from | to | approaches        | route |
+            | s    | e  | unrestricted curb | ab,bc |

features/testbot/bearing_param.feature

@@ -108,12 +108,12 @@ Feature: Bearing parameter
             | ha    | yes    | ring |
 
         When I route I should get
-            | from | to | bearings | route                  | bearing                             |
-            | 0    | q  | 0 90     | ia,ring,ring,ring,ring | 0->0,0->90,180->270,270->0,90->0    |
-            | 0    | a  | 45 90    | jb,ring,ring,ring,ring | 0->45,45->180,180->270,270->0,90->0 |
-            | 0    | q  | 90 90    | kc,ring,ring,ring      | 0->90,90->180,270->0,90->0          |
-            | 0    | a  | 135 90   | ld,ring,ring,ring      | 0->135,135->270,270->0,90->0        |
-            | 0    | a  | 180 90   | me,ring,ring,ring      | 0->180,180->270,270->0,90->0        |
-            | 0    | a  | 225 90   | nf,ring,ring           | 0->225,225->0,90->0                 |
-            | 0    | a  | 270 90   | og,ring,ring           | 0->270,270->0,90->0                 |
-            | 0    | a  | 315 90   | ph,ring,ring           | 0->315,315->90,90->0                |
+            | from | to | bearings | route                       | bearing                                   |
+            |    0 | q  | 0 90     | ia,ring,ring,ring,ring,ring | 0->0,0->90,180->270,270->0,0->90,90->0    |
+            |    0 | a  | 45 90    | jb,ring,ring,ring,ring,ring | 0->45,45->180,180->270,270->0,0->90,90->0 |
+            |    0 | q  | 90 90    | kc,ring,ring,ring,ring      | 0->90,90->180,270->0,0->90,90->0          |
+            |    0 | a  | 135 90   | ld,ring,ring,ring,ring      | 0->135,135->270,270->0,0->90,90->0        |
+            |    0 | a  | 180 90   | me,ring,ring,ring,ring      | 0->180,180->270,270->0,0->90,90->0        |
+            |    0 | a  | 225 90   | nf,ring,ring,ring           | 0->225,225->0,0->90,90->0                 |
+            |    0 | a  | 270 90   | og,ring,ring,ring           | 0->270,270->0,0->90,90->0                 |
+            |    0 | a  | 315 90   | ph,ring,ring                | 0->315,315->90,90->0                      |

features/testbot/distance.feature

@@ -226,3 +226,22 @@ Feature: Distance calculation
             | x    | v  | xv,xv | 424m +-1 |
             | x    | w  | xw,xw | 360m +-1 |
             | x    | y  | xy,xy | 316m +-1 |
+
+
+    # Check rounding errors
+    Scenario: Distances Long distances
+        Given a grid size of 1000 meters
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes    |
+            | abcd |
+
+        When I route I should get
+            | from | to | distance  |
+            | a    | b  | 1000m +-3 |
+            | a    | c  | 2000m +-3 |
+            | a    | d  | 3000m +-3 |

features/testbot/distance_matrix.feature

@@ -1,14 +1,12 @@
 @matrix @testbot
 Feature: Basic Distance Matrix
-# note that results are travel time, specified in 1/10th of seconds
-# since testbot uses a default speed of 100m/10s, the result matches
-# the number of meters as long as the way type is the default 'primary'
+# note that results of travel distance are in metres
 
     Background:
         Given the profile "testbot"
         And the partition extra arguments "--small-component-size 1 --max-cell-sizes 2,4,8,16"
 
-    Scenario: Testbot - Travel time matrix of minimal network
+    Scenario: Testbot - Travel distance matrix of minimal network
         Given the node map
             """
             a b
@@ -18,12 +16,99 @@ Feature: Basic Distance Matrix
             | nodes |
             | ab    |
 
-        When I request a travel time matrix I should get
-            |   | a  | b  |
-            | a | 0  | 10 |
-            | b | 10 | 0  |
+        When I request a travel distance matrix I should get
+            |   | a      | b      |
+            | a | 0      | 100+-1 |
+            | b | 100+-1 | 0      |
 
-    Scenario: Testbot - Travel time matrix with different way speeds
+    Scenario: Testbot - Travel distance matrix of minimal network with toll exclude
+        Given the query options
+            | exclude  | toll        |
+
+        Given the node map
+            """
+            a b
+            c d
+            """
+
+        And the ways
+            | nodes | highway  | toll | #                                                       |
+            | ab    | motorway |      | not drivable for exclude=motorway                       |
+            | cd    | primary  |      | always drivable                                         |
+            | ac    | primary  | yes  | not drivable for exclude=toll and exclude=motorway,toll |
+            | bd    | motorway | yes  | not drivable for exclude=toll and exclude=motorway,toll |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b      | c      | d      |
+            | a | 0      | 100+-1 |        |        |
+            | b | 100+-1 | 0      |        |        |
+            | c |        |        | 0      | 100+-1 |
+            | d |        |        | 100+-1 | 0      |
+
+    Scenario: Testbot - Travel distance matrix of minimal network with motorway exclude
+        Given the query options
+            | exclude  | motorway  |
+
+        Given the node map
+            """
+            a b
+            c d
+            """
+
+        And the ways
+            | nodes | highway     | #                                 |
+            | ab    | motorway    | not drivable for exclude=motorway |
+            | cd    | residential |                                   |
+            | ac    | residential |                                   |
+            | bd    | residential |                                   |
+
+        When I request a travel distance matrix I should get
+            |   | a | b      | c      | d      |
+            | a | 0 | 300+-2 | 100+-2 | 200+-2 |
+
+    Scenario: Testbot - Travel distance matrix of minimal network disconnected motorway exclude
+        Given the query options
+            | exclude  | motorway  |
+        And the extract extra arguments "--small-component-size 4"
+
+        Given the node map
+            """
+            ab                  efgh
+            cd
+            """
+
+        And the ways
+            | nodes | highway     | #                                 |
+            | be    | motorway    | not drivable for exclude=motorway |
+            | abcd  | residential |                                   |
+            | efgh  | residential |                                   |
+
+        When I request a travel distance matrix I should get
+            |   | a | b     | e |
+            | a | 0 | 50+-1 |   |
+
+    Scenario: Testbot - Travel distance matrix of minimal network with motorway and toll excludes
+        Given the query options
+            | exclude  | motorway,toll  |
+
+        Given the node map
+            """
+            a b          e f
+            c d          g h
+            """
+
+        And the ways
+            | nodes | highway     | toll | #                                 |
+            | be    | motorway    |      | not drivable for exclude=motorway |
+            | dg    | primary     | yes  | not drivable for exclude=toll     |
+            | abcd  | residential |      |                                   |
+            | efgh  | residential |      |                                   |
+
+        When I request a travel distance matrix I should get
+            |   | a | b      | e | g |
+            | a | 0 | 100+-1 |   |   |
+
+    Scenario: Testbot - Travel distance matrix with different way speeds
         Given the node map
             """
             a b c d
@@ -35,40 +120,25 @@ Feature: Basic Distance Matrix
             | bc    | secondary |
             | cd    | tertiary  |
 
-        When I request a travel time matrix I should get
-            |   | a  | b  | c  | d  |
-            | a | 0  | 10 | 30 | 60 |
-            | b | 10 | 0  | 20 | 50 |
-            | c | 30 | 20 | 0  | 30 |
-            | d | 60 | 50 | 30 | 0  |
+        When I request a travel distance matrix I should get
+            |   | a      | b      | c      | d      |
+            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
+            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
+            | c | 200+-1 | 100+-1 | 0      | 100+-1 |
+            | d | 300+-1 | 200+-1 | 100+-1 | 0     |
 
-        When I request a travel time matrix I should get
-            |   | a  | b  | c  | d  |
-            | a | 0  | 10 | 30 | 60 |
+        When I request a travel distance matrix I should get
+            |   | a | b      | c      | d      |
+            | a | 0 | 100+-1 | 200+-1 | 300+-1 |
 
-        When I request a travel time matrix I should get
-            |   |  a |
-            | a |  0 |
-            | b | 10 |
-            | c | 30 |
-            | d | 60 |
+        When I request a travel distance matrix I should get
+            |   | a      |
+            | a | 0      |
+            | b | 100+-1 |
+            | c | 200+-1 |
+            | d | 300+-1 |
 
-    Scenario: Testbot - Travel time matrix with fuzzy match
-        Given the node map
-            """
-            a b
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-
-        When I request a travel time matrix I should get
-            |   | a  | b  |
-            | a | 0  | 10 |
-            | b | 10 | 0  |
-
-    Scenario: Testbot - Travel time matrix of small grid
+    Scenario: Testbot - Travel distance matrix of small grid
         Given the node map
             """
             a b c
@@ -83,14 +153,14 @@ Feature: Basic Distance Matrix
             | be    |
             | cf    |
 
-        When I request a travel time matrix I should get
-            |   | a  | b  | e  | f  |
-            | a | 0  | 10 | 20 | 30 |
-            | b | 10 | 0  | 10 | 20 |
-            | e | 20 | 10 | 0  | 10 |
-            | f | 30 | 20 | 10 | 0  |
+        When I request a travel distance matrix I should get
+            |   | a      | b      | e      | f      |
+            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
+            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
+            | e | 200+-1 | 100+-1 | 0      | 100+-1 |
+            | f | 300+-1 | 200+-1 | 100+-1 | 0      |
 
-    Scenario: Testbot - Travel time matrix of network with unroutable parts
+    Scenario: Testbot - Travel distance matrix of network with unroutable parts
         Given the node map
             """
             a b
@@ -100,12 +170,12 @@ Feature: Basic Distance Matrix
             | nodes | oneway |
             | ab    | yes    |
 
-        When I request a travel time matrix I should get
-            |   | a | b  |
-            | a | 0 | 10 |
-            | b |   | 0  |
+        When I request a travel distance matrix I should get
+            |   | a | b      |
+            | a | 0 | 100+-1 |
+            | b |   | 0      |
 
-    Scenario: Testbot - Travel time matrix of network with oneways
+    Scenario: Testbot - Travel distance matrix of network with oneways
         Given the node map
             """
             x a b y
@@ -118,14 +188,14 @@ Feature: Basic Distance Matrix
             | xa    |        |
             | by    |        |
 
-        When I request a travel time matrix I should get
-            |   | x  | y   | d  | e  |
-            | x | 0  | 30  | 40 | 30 |
-            | y | 50 | 0   | 30 | 20 |
-            | d | 20 | 30  | 0  | 30 |
-            | e | 30 | 40  | 10 | 0  |
+        When I request a travel distance matrix I should get
+            |   | x      | y      | d      | e      |
+            | x | 0      | 300+-2 | 400+-2 | 300+-2 |
+            | y | 500+-2 | 0      | 300+-2 | 200+-2 |
+            | d | 200+-2 | 300+-2 | 0      | 300+-2 |
+            | e | 300+-2 | 400+-2 | 100+-2 | 0      |
 
-    Scenario: Testbot - Rectangular travel time matrix
+    Scenario: Testbot - Rectangular travel distance matrix
         Given the node map
             """
             a b c
@@ -140,51 +210,57 @@ Feature: Basic Distance Matrix
             | be    |
             | cf    |
 
-        When I request a travel time matrix I should get
-            |   | a | b  | e  | f  |
-            | a | 0 | 10 | 20 | 30 |
+        When I route I should get
+            | from | to | distance  |
+            | e    | a  | 200m +- 1 |
+            | e    | b  | 100m +- 1 |
+            | f    | a  | 300m +- 1 |
+            | f    | b  | 200m +- 1 |
 
-        When I request a travel time matrix I should get
-            |   |  a |
-            | a |  0 |
-            | b | 10 |
-            | e | 20 |
-            | f | 30 |
+        When I request a travel distance matrix I should get
+            |   | a | b      | e      | f      |
+            | a | 0 | 100+-1 | 200+-1 | 300+-1 |
 
-        When I request a travel time matrix I should get
-            |   |  a |  b |  e |  f |
-            | a |  0 | 10 | 20 | 30 |
-            | b | 10 |  0 | 10 | 20 |
+        When I request a travel distance matrix I should get
+            |   | a      |
+            | a | 0      |
+            | b | 100+-1 |
+            | e | 200+-1 |
+            | f | 300+-1 |
 
-        When I request a travel time matrix I should get
-            |   |  a |  b |
-            | a |  0 | 10 |
-            | b | 10 |  0 |
-            | e | 20 | 10 |
-            | f | 30 | 20 |
+        When I request a travel distance matrix I should get
+            |   | a      | b      | e      | f      |
+            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
+            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
 
-        When I request a travel time matrix I should get
-            |   |  a |  b |  e |  f |
-            | a |  0 | 10 | 20 | 30 |
-            | b | 10 |  0 | 10 | 20 |
-            | e | 20 | 10 |  0 | 10 |
+        When I request a travel distance matrix I should get
+            |   | a      | b      |
+            | a | 0      | 100+-1 |
+            | b | 100+-1 | 0      |
+            | e | 200+-1 | 100+-1 |
+            | f | 300+-1 | 200+-1 |
 
-        When I request a travel time matrix I should get
-            |   |  a |  b |  e |
-            | a |  0 | 10 | 20 |
-            | b | 10 |  0 | 10 |
-            | e | 20 | 10 |  0 |
-            | f | 30 | 20 | 10 |
+        When I request a travel distance matrix I should get
+            |   | a      | b      | e      | f      |
+            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
+            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
+            | e | 200+-1 | 100+-1 | 0      | 100+-1 |
 
-        When I request a travel time matrix I should get
-            |   |  a |  b |  e |  f |
-            | a |  0 | 10 | 20 | 30 |
-            | b | 10 |  0 | 10 | 20 |
-            | e | 20 | 10 |  0 | 10 |
-            | f | 30 | 20 | 10 |  0 |
+        When I request a travel distance matrix I should get
+            |   | a      | b      | e      |
+            | a | 0      | 100+-1 | 200+-1 |
+            | b | 100+-1 | 0      | 100+-1 |
+            | e | 200+-1 | 100+-1 | 0      |
+            | f | 300+-1 | 200+-1 | 100+-1 |
 
+        When I request a travel distance matrix I should get
+            |   | a      | b      | e      | f      |
+            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
+            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
+            | e | 200+-1 | 100+-1 | 0      | 100+-1 |
+            | f | 300+-1 | 200+-1 | 100+-1 | 0      |
 
-     Scenario: Testbot - Travel time 3x2 matrix
+     Scenario: Testbot - Travel distance 3x2 matrix
         Given the node map
             """
             a b c
@@ -199,10 +275,11 @@ Feature: Basic Distance Matrix
             | be    |
             | cf    |
 
-        When I request a travel time matrix I should get
-            |   | b  | e  | f  |
-            | a | 10 | 20 | 30 |
-            | b | 0  | 10 | 20 |
+
+        When I request a travel distance matrix I should get
+            |   | b      | e      | f      |
+            | a | 100+-1 | 200+-1 | 300+-1 |
+            | b | 0      | 100+-1 | 200+-1 |
 
     Scenario: Testbot - All coordinates are from same small component
         Given a grid size of 300 meters
@@ -221,10 +298,10 @@ Feature: Basic Distance Matrix
             | da    |
             | fg    |
 
-        When I request a travel time matrix I should get
-            |   | f  | g  |
-            | f | 0  | 30 |
-            | g | 30 |  0 |
+        When I request a travel distance matrix I should get
+            |   | f      | g      |
+            | f | 0      | 300+-2 |
+            | g | 300+-2 | 0      |
 
     Scenario: Testbot - Coordinates are from different small component and snap to big CC
         Given a grid size of 300 meters
@@ -244,14 +321,25 @@ Feature: Basic Distance Matrix
             | fg    |
             | hi    |
 
-        When I request a travel time matrix I should get
-            |   | f  | g  | h  | i  |
-            | f | 0  | 30 | 0  | 30 |
-            | g | 30 |  0 | 30 | 0  |
-            | h | 0  | 30 | 0  | 30 |
-            | i | 30 |  0 | 30 | 0  |
+        When I route I should get
+            | from | to | distance |
+            | f    | g  | 300m     |
+            | f    | i  | 300m     |
+            | g    | f  | 300m     |
+            | g    | h  | 300m     |
+            | h    | g  | 300m     |
+            | h    | i  | 300m     |
+            | i    | f  | 300m     |
+            | i    | h  | 300m     |
 
-    Scenario: Testbot - Travel time matrix with loops
+        When I request a travel distance matrix I should get
+            |   | f      | g      | h      | i      |
+            | f | 0      | 300+-2 | 0      | 300+-2 |
+            | g | 300+-2 | 0      | 300+-2 | 0      |
+            | h | 0      | 300+-2 | 0      | 300+-2 |
+            | i | 300+-2 | 0      | 300+-2 | 0      |
+
+    Scenario: Testbot - Travel distance matrix with loops
         Given the node map
             """
             a 1 2 b
@@ -265,14 +353,15 @@ Feature: Basic Distance Matrix
             | cd    | yes |
             | da    | yes |
 
-        When I request a travel time matrix I should get
-            |   | 1      | 2      | 3      | 4  |
-            | 1 | 0      | 10 +-1 | 40 +-1 | 50 +-1 |
-            | 2 | 70 +-1 | 0      | 30 +-1 | 40 +-1 |
-            | 3 | 40 +-1 | 50 +-1 | 0      | 10 +-1 |
-            | 4 | 30 +-1 | 40 +-1 | 70 +-1 | 0  |
+        When I request a travel distance matrix I should get
+            |   | 1      | 2      | 3      | 4      |
+            | 1 | 0      | 100+-1 | 400+-1 | 500+-1 |
+            | 2 | 700+-1 | 0      | 300+-1 | 400+-1 |
+            | 3 | 400+-1 | 500+-1 | 0      | 100+-1 |
+            | 4 | 300+-1 | 400+-1 | 700+-1 | 0      |
 
-    Scenario: Testbot - Travel time matrix based on segment durations
+
+    Scenario: Testbot - Travel distance matrix based on segment durations
         Given the profile file
         """
         local functions = require('testbot')
@@ -301,20 +390,19 @@ Feature: Basic Distance Matrix
           """
 
         And the ways
-          | nodes |
-          | abcd  |
-          | ce    |
+            | nodes |
+            | abcd  |
+            | ce    |
 
-        When I request a travel time matrix I should get
-          |   |  a |  b |  c |  d |  e |
-          | a |  0 | 11 | 22 | 33 | 33 |
-          | b | 11 |  0 | 11 | 22 | 22 |
-          | c | 22 | 11 |  0 | 11 | 11 |
-          | d | 33 | 22 | 11 |  0 | 22 |
-          | e | 33 | 22 | 11 | 22 |  0 |
+        When I request a travel distance matrix I should get
+            |   | a      | b      | c      | d      | e      |
+            | a | 0      | 100+-2 | 200+-2 | 300+-2 | 400+-2 |
+            | b | 100+-2 | 0      | 100+-2 | 200+-2 | 300+-2 |
+            | c | 200+-2 | 100+-2 | 0      | 100+-2 | 200+-2 |
+            | d | 300+-2 | 200+-2 | 100+-2 | 0      | 300+-2 |
+            | e | 400+-2 | 300+-2 | 200+-2 | 300+-2 | 0      |
 
-
-    Scenario: Testbot - Travel time matrix for alternative loop paths
+    Scenario: Testbot - Travel distance matrix for alternative loop paths
         Given the profile file
         """
         local functions = require('testbot')
@@ -350,62 +438,132 @@ Feature: Basic Distance Matrix
             | dc    | yes    |
             | ca    | yes    |
 
-        When I request a travel time matrix I should get
-          |   |   1 |   2 |   3 |   4 |    5 |   6 |   7 |   8 |
-          | 1 |   0 |  11 |   3 |   2 |    6 |   5 | 8.9 | 7.9 |
-          | 2 |   1 |   0 |   4 |   3 |    7 |   6 | 9.9 | 8.9 |
-          | 3 |   9 |   8 |   0 |  11 |    3 |   2 | 5.9 | 4.9 |
-          | 4 |  10 |   9 |   1 |   0 |    4 |   3 | 6.9 | 5.9 |
-          | 5 |   6 |   5 |   9 |   8 |    0 |  11 | 2.9 | 1.9 |
-          | 6 |   7 |   6 |  10 |   9 |    1 |   0 | 3.9 | 2.9 |
-          | 7 | 3.1 | 2.1 | 6.1 | 5.1 |  9.1 | 8.1 |   0 |  11 |
-          | 8 | 4.1 | 3.1 | 7.1 | 6.1 | 10.1 | 9.1 |   1 | 0   |
+        When I request a travel distance matrix I should get
+            |   | 1       | 2       | 3       | 4       | 5       | 6       | 7       | 8       |
+            | 1 | 0       | 1100+-5 | 300+-5  | 200+-5  | 600+-5  | 500+-5  | 900+-5  | 800+-5  |
+            | 2 | 100+-5  | 0       | 400+-5  | 300+-5  | 700+-5  | 600+-5  | 1000+-5 | 900+-5  |
+            | 3 | 900+-5  | 800+-5  | 0       | 1100+-5 | 300+-5  | 200+-5  | 600+-5  | 500+-5  |
+            | 4 | 1000+-5 | 900+-5  | 100+-5  | 0       | 400+-5  | 300+-5  | 700+-5  | 600+-5  |
+            | 5 | 600+-5  | 500+-5  | 900+-5  | 800+-5  | 0       | 1100+-5 | 300+-5  | 200+-5  |
+            | 6 | 700+-5  | 600+-5  | 1000+-5 | 900+-5  | 100+-5  | 0       | 400+-5  | 300+-5  |
+            | 7 | 300+-5  | 200+-5  | 600+-5  | 500+-5  | 900+-5  | 800+-5  | 0       | 1100+-5 |
+            | 8 | 400+-5  | 300+-5  | 700+-5  | 600+-5  | 1000+-5 | 900+-5  | 100+-5  | 0       |
 
+        When I request a travel distance matrix I should get
+            |   | 1       |
+            | 1 | 0       |
+            | 2 | 100+-5  |
+            | 3 | 900+-5  |
+            | 4 | 1000+-5 |
+            | 5 | 600+-5  |
+            | 6 | 700+-5  |
+            | 7 | 300+-5  |
+            | 8 | 400+-5  |
 
-    Scenario: Testbot - Travel time matrix with ties
-        Given the profile file
-        """
-        local functions = require('testbot')
-        functions.process_segment = function(profile, segment)
-          segment.weight = 1
-          segment.duration = 1
-        end
-        functions.process_turn = function(profile, turn)
-          if turn.angle >= 0 then
-            turn.duration = 16
-          else
-            turn.duration = 4
-          end
-          turn.weight = 0
-        end
-        return functions
-        """
-        And the node map
+    Scenario: Testbot - Travel distance matrix with ties
+        Given the node map
             """
-            a     b
+            a        b
 
             c     d
             """
 
         And the ways
-          | nodes |
-          | ab    |
-          | ac    |
-          | bd    |
-          | dc    |
-
+            | nodes |
+            | ab    |
+            | ac    |
+            | bd    |
+            | dc    |
 
         When I route I should get
-          | from | to | route | distance | time | weight |
-          | a    | c  | ac,ac | 200m     | 5s   |      5 |
+            | from | to | route | distance | time | weight |
+            | a    | c  | ac,ac | 200m     | 20s  |     20 |
 
-        When I request a travel time matrix I should get
-          |   | a | b | c |  d |
-          | a | 0 | 1 | 5 | 10 |
+        When I route I should get
+            | from | to | route    | distance  |
+            | a    | b  | ab,ab    | 450m      |
+            | a    | c  | ac,ac    | 200m      |
+            | a    | d  | ac,dc,dc | 500m +- 1 |
 
-        When I request a travel time matrix I should get
-          |   |  a |
-          | a |  0 |
-          | b |  1 |
-          | c | 15 |
-          | d | 10 |
+        When I request a travel distance matrix I should get
+            |   | a | b      | c      | d      |
+            | a | 0 | 450+-2 | 200+-2 | 500+-2 |
+
+        When I request a travel distance matrix I should get
+            |   | a      |
+            | a | 0      |
+            | b | 450+-2 |
+            | c | 200+-2 |
+            | d | 500+-2 |
+
+        When I request a travel distance matrix I should get
+            |   | a      | c      |
+            | a | 0      | 200+-2 |
+            | c | 200+-2 | 0      |
+
+
+    # Check rounding errors
+    Scenario: Testbot - Long distances in tables
+        Given a grid size of 1000 meters
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes    |
+            | abcd     |
+
+        When I request a travel distance matrix I should get
+            |   | a | b       | c       | d       |
+            | a | 0 | 1000+-3 | 2000+-3 | 3000+-3 |
+
+
+    Scenario: Testbot - OneToMany vs ManyToOne
+        Given the node map
+            """
+            a b
+            c
+            """
+
+        And the ways
+            | nodes  | oneway |
+            | ab     | yes    |
+            | ac     |        |
+            | bc     |        |
+
+        When I request a travel distance matrix I should get
+            |   |   a   | b      |
+            | b | 240.4 | 0      |
+
+        When I request a travel distance matrix I should get
+            |   |   a   |
+            | a |   0   |
+            | b | 240.4 |
+
+    Scenario: Testbot - Varying distances between nodes
+        Given the node map
+            """
+            a b   c      d
+
+            e
+
+
+
+            f
+            """
+
+        And the ways
+            | nodes  | oneway |
+            | feabcd | yes    |
+            | ec     |        |
+            | fd     |        |
+
+        When I request a travel distance matrix I should get
+            |   | a       | b       | c       | d       | e       | f       |
+            | a | 0       | 100+-1  | 300+-1  | 650+-1  | 1930+-1 | 1533+-1 |
+            | b | 760+-1  | 0       | 200+-1  | 550+-1  | 1830+-1 | 1433+-1 |
+            | c | 560+-2  | 660+-2  | 0       | 350+-1  | 1630+-1 | 1233+-1 |
+            | d | 1480+-2 | 1580+-1 | 1780+-1 | 0       | 1280+-1 | 883+-1  |
+            | e | 200+-2  | 300+-2  | 500+-1  | 710+-1  | 0       | 1593+-1 |
+            | f | 597+-1  | 696+-1  | 896+-1  | 1108+-1 | 400+-3  | 0       |

features/testbot/duration_matrix.feature

@@ -0,0 +1,512 @@
+@matrix @testbot
+Feature: Basic Duration Matrix
+# note that results of travel time are in seconds
+
+    Background:
+        Given the profile "testbot"
+        And the partition extra arguments "--small-component-size 1 --max-cell-sizes 2,4,8,16"
+
+    Scenario: Testbot - Travel time matrix of minimal network
+        Given the node map
+            """
+            a b
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  |
+            | a | 0  | 10 |
+            | b | 10 | 0  |
+
+    @ch
+    Scenario: Testbot - Travel time matrix of minimal network with toll exclude
+        Given the query options
+            | exclude  | toll        |
+
+        Given the node map
+            """
+            a b
+            c d
+            """
+
+        And the ways
+            | nodes | highway  | toll | #                                        |
+            | ab    | motorway |      | not drivable for exclude=motorway        |
+            | cd    | primary  |      | always drivable                          |
+            | ac    | motorway | yes  | not drivable for exclude=toll and exclude=motorway,toll |
+            | bd    | motorway | yes  | not drivable for exclude=toll and exclude=motorway,toll |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | c  | d  |
+            | a | 0  | 15 |    |    |
+            | b | 15 | 0  |    |    |
+            | c |    |    | 0  | 10 |
+            | d |    |    | 10 | 0  |
+
+    @ch
+    Scenario: Testbot - Travel time matrix of minimal network with motorway exclude
+        Given the query options
+            | exclude  | motorway  |
+
+        Given the node map
+            """
+            a b
+            c d
+            """
+
+        And the ways
+            | nodes | highway     | #                                 |
+            | ab    | motorway    | not drivable for exclude=motorway |
+            | cd    | residential |                                   |
+            | ac    | residential |                                   |
+            | bd    | residential |                                   |
+
+        When I request a travel time matrix I should get
+            |   | a | b  | c  | d  |
+            | a | 0 | 45 | 15 | 30 |
+
+    @ch
+    Scenario: Testbot - Travel time matrix of minimal network disconnected motorway exclude
+        Given the query options
+            | exclude  | motorway  |
+
+        Given the node map
+            """
+            ab                  efgh
+            cd
+            """
+
+        And the ways
+            | nodes | highway     | #                                 |
+            | be    | motorway    | not drivable for exclude=motorway |
+            | abcd  | residential |                                   |
+            | efgh  | residential |                                   |
+
+        When I request a travel time matrix I should get
+            |   | a | b   | e |
+            | a | 0 | 7.5 |   |
+
+    @ch
+    Scenario: Testbot - Travel time matrix of minimal network with motorway and toll excludes
+        Given the query options
+            | exclude  | motorway,toll  |
+
+        Given the node map
+            """
+            a b          e f
+            c d          g h
+            """
+
+        And the ways
+            | nodes | highway     | toll | #                                 |
+            | be    | motorway    |      | not drivable for exclude=motorway |
+            | dg    | primary     | yes  | not drivable for exclude=toll     |
+            | abcd  | residential |      |                                   |
+            | efgh  | residential |      |                                   |
+
+        When I request a travel time matrix I should get
+            |   | a | b  | e | g |
+            | a | 0 | 15 |   |   |
+
+    Scenario: Testbot - Travel time matrix with different way speeds
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes | highway   |
+            | ab    | primary   |
+            | bc    | secondary |
+            | cd    | tertiary  |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | c  | d  |
+            | a | 0  | 10 | 30 | 60 |
+            | b | 10 | 0  | 20 | 50 |
+            | c | 30 | 20 | 0  | 30 |
+            | d | 60 | 50 | 30 | 0  |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | c  | d  |
+            | a | 0  | 10 | 30 | 60 |
+
+        When I request a travel time matrix I should get
+            |   |  a |
+            | a |  0 |
+            | b | 10 |
+            | c | 30 |
+            | d | 60 |
+
+
+    Scenario: Testbot - Travel time matrix of small grid
+        Given the node map
+            """
+            a b c
+            d e f
+            """
+
+        And the ways
+            | nodes |
+            | abc   |
+            | def   |
+            | ad    |
+            | be    |
+            | cf    |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | e  | f  |
+            | a | 0  | 10 | 20 | 30 |
+            | b | 10 | 0  | 10 | 20 |
+            | e | 20 | 10 | 0  | 10 |
+            | f | 30 | 20 | 10 | 0  |
+
+
+    Scenario: Testbot - Travel time matrix of network with unroutable parts
+        Given the node map
+            """
+            a b
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+
+        When I request a travel time matrix I should get
+            |   | a | b  |
+            | a | 0 | 10 |
+            | b |   | 0  |
+
+
+    Scenario: Testbot - Travel time matrix of network with oneways
+        Given the node map
+            """
+            x a b y
+              d e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | abeda | yes    |
+            | xa    |        |
+            | by    |        |
+
+        When I request a travel time matrix I should get
+            |   | x  | y   | d  | e  |
+            | x | 0  | 30  | 40 | 30 |
+            | y | 50 | 0   | 30 | 20 |
+            | d | 20 | 30  | 0  | 30 |
+            | e | 30 | 40  | 10 | 0  |
+
+
+    Scenario: Testbot - Rectangular travel time matrix
+        Given the node map
+            """
+            a b c
+            d e f
+            """
+
+        And the ways
+            | nodes |
+            | abc   |
+            | def   |
+            | ad    |
+            | be    |
+            | cf    |
+
+        When I request a travel time matrix I should get
+            |   | a | b  | e  | f  |
+            | a | 0 | 10 | 20 | 30 |
+
+        When I request a travel time matrix I should get
+            |   |  a |
+            | a |  0 |
+            | b | 10 |
+            | e | 20 |
+            | f | 30 |
+
+        When I request a travel time matrix I should get
+            |   |  a |  b |  e |  f |
+            | a |  0 | 10 | 20 | 30 |
+            | b | 10 |  0 | 10 | 20 |
+
+        When I request a travel time matrix I should get
+            |   |  a |  b |
+            | a |  0 | 10 |
+            | b | 10 |  0 |
+            | e | 20 | 10 |
+            | f | 30 | 20 |
+
+        When I request a travel time matrix I should get
+            |   |  a |  b |  e |  f |
+            | a |  0 | 10 | 20 | 30 |
+            | b | 10 |  0 | 10 | 20 |
+            | e | 20 | 10 |  0 | 10 |
+
+        When I request a travel time matrix I should get
+            |   |  a |  b |  e |
+            | a |  0 | 10 | 20 |
+            | b | 10 |  0 | 10 |
+            | e | 20 | 10 |  0 |
+            | f | 30 | 20 | 10 |
+
+        When I request a travel time matrix I should get
+            |   |  a |  b |  e |  f |
+            | a |  0 | 10 | 20 | 30 |
+            | b | 10 |  0 | 10 | 20 |
+            | e | 20 | 10 |  0 | 10 |
+            | f | 30 | 20 | 10 |  0 |
+
+     Scenario: Testbot - Travel time 3x2 matrix
+        Given the node map
+            """
+            a b c
+            d e f
+            """
+
+        And the ways
+            | nodes |
+            | abc   |
+            | def   |
+            | ad    |
+            | be    |
+            | cf    |
+
+        When I request a travel time matrix I should get
+            |   | b  | e  | f  |
+            | a | 10 | 20 | 30 |
+            | b | 0  | 10 | 20 |
+
+
+    Scenario: Testbot - All coordinates are from same small component
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the node map
+            """
+            a b   f
+            d e   g
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | be    |
+            | ed    |
+            | da    |
+            | fg    |
+
+        When I request a travel time matrix I should get
+            |   | f  | g  |
+            | f | 0  | 30 |
+            | g | 30 |  0 |
+
+
+    Scenario: Testbot - Coordinates are from different small component and snap to big CC
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the node map
+            """
+            a b   f h
+            d e   g i
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | be    |
+            | ed    |
+            | da    |
+            | fg    |
+            | hi    |
+
+        When I request a travel time matrix I should get
+            |   | f  | g  | h  | i  |
+            | f | 0  | 30 | 0  | 30 |
+            | g | 30 |  0 | 30 | 0  |
+            | h | 0  | 30 | 0  | 30 |
+            | i | 30 |  0 | 30 | 0  |
+
+
+    Scenario: Testbot - Travel time matrix with loops
+        Given the node map
+            """
+            a 1 2 b
+            d 4 3 c
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes |
+            | bc    | yes |
+            | cd    | yes |
+            | da    | yes |
+
+        When I request a travel time matrix I should get
+            |   | 1      | 2      | 3      | 4      |
+            | 1 | 0      | 10 +-1 | 40 +-1 | 50 +-1 |
+            | 2 | 70 +-1 | 0      | 30 +-1 | 40 +-1 |
+            | 3 | 40 +-1 | 50 +-1 | 0      | 10 +-1 |
+            | 4 | 30 +-1 | 40 +-1 | 70 +-1 | 0      |
+
+
+    Scenario: Testbot - Travel time matrix based on segment durations
+        Given the profile file
+        """
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.traffic_signal_penalty = 0
+          profile.u_turn_penalty = 0
+          return profile
+        end
+
+        functions.process_segment = function(profile, segment)
+          segment.weight = 2
+          segment.duration = 11
+        end
+
+        return functions
+        """
+
+        And the node map
+          """
+          a-b-c-d
+              .
+              e
+          """
+
+        And the ways
+          | nodes |
+          | abcd  |
+          | ce    |
+
+        When I request a travel time matrix I should get
+          |   |  a |  b |  c |  d |  e |
+          | a |  0 | 11 | 22 | 33 | 33 |
+          | b | 11 |  0 | 11 | 22 | 22 |
+          | c | 22 | 11 |  0 | 11 | 11 |
+          | d | 33 | 22 | 11 |  0 | 22 |
+          | e | 33 | 22 | 11 | 22 |  0 |
+
+
+    Scenario: Testbot - Travel time matrix for alternative loop paths
+        Given the profile file
+        """
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.traffic_signal_penalty = 0
+          profile.u_turn_penalty = 0
+          profile.weight_precision = 3
+          return profile
+        end
+
+        functions.process_segment = function(profile, segment)
+          segment.weight = 777
+          segment.duration = 3
+        end
+
+        return functions
+        """
+        And the node map
+            """
+            a 2 1 b
+            7     4
+            8     3
+            c 5 6 d
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+            | bd    | yes    |
+            | dc    | yes    |
+            | ca    | yes    |
+
+        When I request a travel time matrix I should get
+          |   |   1 |   2 |   3 |   4 |    5 |   6 |   7 |   8 |
+          | 1 |   0 |  11 |   3 |   2 |    6 |   5 | 8.9 | 7.9 |
+          | 2 |   1 |   0 |   4 |   3 |    7 |   6 | 9.9 | 8.9 |
+          | 3 |   9 |   8 |   0 |  11 |    3 |   2 | 5.9 | 4.9 |
+          | 4 |  10 |   9 |   1 |   0 |    4 |   3 | 6.9 | 5.9 |
+          | 5 |   6 |   5 |   9 |   8 |    0 |  11 | 2.9 | 1.9 |
+          | 6 |   7 |   6 |  10 |   9 |    1 |   0 | 3.9 | 2.9 |
+          | 7 | 3.1 | 2.1 | 6.1 | 5.1 |  9.1 | 8.1 |   0 |  11 |
+          | 8 | 4.1 | 3.1 | 7.1 | 6.1 | 10.1 | 9.1 |   1 | 0   |
+
+
+    Scenario: Testbot - Travel time matrix with ties
+        Given the profile file
+        """
+        local functions = require('testbot')
+        functions.process_segment = function(profile, segment)
+          segment.weight = 1
+          segment.duration = 1
+        end
+        functions.process_turn = function(profile, turn)
+          if turn.angle >= 0 then
+            turn.duration = 16
+          else
+            turn.duration = 4
+          end
+          turn.weight = 0
+        end
+        return functions
+        """
+        And the node map
+            """
+            a     b
+
+            c     d
+            """
+
+        And the ways
+          | nodes |
+          | ab    |
+          | ac    |
+          | bd    |
+          | dc    |
+
+        When I route I should get
+          | from | to | route | distance | time | weight |
+          | a    | c  | ac,ac | 200m     | 5s   |      5 |
+
+        When I request a travel time matrix I should get
+          |   | a | b | c |  d |
+          | a | 0 | 1 | 5 | 10 |
+
+        When I request a travel time matrix I should get
+          |   |  a |
+          | a |  0 |
+          | b |  1 |
+          | c | 15 |
+          | d | 10 |
+
+    Scenario: Testbot - OneToMany vs ManyToOne
+        Given the node map
+            """
+            a b
+            c
+            """
+
+        And the ways
+            | nodes  | oneway |
+            | ab     | yes    |
+            | ac     |        |
+            | bc     |        |
+
+        When I request a travel time matrix I should get
+            |   |   a  |  b  |
+            | b | 24.1 |  0  |
+
+        When I request a travel time matrix I should get
+            |   |   a   |
+            | a |   0   |
+            | b | 24.1  |

features/testbot/fixed.feature

@@ -39,5 +39,64 @@ Feature: Fixed bugs, kept to check for regressions
             | de    | yes    |
 
         When I route I should get
-            | from | to | route     |
-            | 1    | 2  | bcd,bcd   |
+            | from | to | route   |
+            | 1    | 2  | bcd,bcd |
+
+    #############################
+    # This test models the OSM map at the location for
+    #    https://github.com/Project-OSRM/osrm-backend/issues/5039
+    #############################
+    Scenario: Mixed Entry and Exit and segregated
+        Given the profile file "car" initialized with
+            """
+            profile.properties.left_hand_driving = true
+            """
+            Given the node locations
+            | node | lon             | lat             |
+            | a    | 171.12889297029 | -42.58425289548 |
+            | b    | 171.1299357     | -42.5849295     |
+            | c    | 171.1295427     | -42.5849385     |
+            | d    | 171.1297356     | -42.5852029     |
+            | e    | 171.1296909     | -42.5851986     |
+            | f    | 171.1295097     | -42.585007      |
+            | g    | 171.1298225     | -42.5851928     |
+            | h    | 171.1300262     | -42.5859122     |
+            | i    | 171.1292651     | -42.584698      |
+            | j    | 171.1297209     | -42.5848569     |
+            | k    | 171.1297188     | -42.5854056     |
+            | l    | 171.1298326     | -42.5857266     |
+            | m    | 171.1298871     | -42.5848922     |
+            | n    | 171.1296505     | -42.585189      |
+            | o    | 171.1295206     | -42.5850862     |
+            | p    | 171.1296106     | -42.5848862     |
+            | q    | 171.1299784     | -42.5850191     |
+            | r    | 171.1298867     | -42.5851671     |
+            | s    | 171.1306955     | -42.5845812     |
+            | t    | 171.129525      | -42.584807      |
+            | u    | 171.1299705     | -42.584984      |
+            | v    | 171.1299067     | -42.5849073     |
+            | w    | 171.1302061     | -42.5848173     |
+            | x    | 171.12975       | -42.5855753     |
+            | y    | 171.129969      | -42.585079      |
+            | 1    | 171.131511926651| -42.584306746421966 |
+            | 2    | 171.128743886947| -42.58414875714669 |
+        And the ways
+            | nodes     | highway | maxspeed | name                    | ref   | surface | junction   | oneway |
+            | ws        | primary | 100      | Taramakau Highway       | SH 6  | asphalt |            |        |
+            | kxlh      | trunk   |          | Otira Highway           | SH 73 |         |            |        |
+            | ai        | primary | 100      | Kumara Junction Highway | SH 6  | asphalt |            |        |
+            | qyrgdenof | primary | 100      | Kumara Junction         |       |         | roundabout | yes    |
+            | ke        | trunk   |          | Otira Highway           | SH 73 |         |            | yes    |
+            | itj       | primary | 100      | Kumara Junction Highway | SH 6  |         |            | yes    |
+            | gk        | trunk   |          | Otira Highway           | SH 73 |         |            | yes    |
+            | fi        | primary | 100      | Kumara Junction Highway | SH 6  |         |            | yes    |
+            | wq        | primary | 100      | Taramakau Highway       | SH 6  |         |            | yes    |
+            | vw        | primary | 100      | Taramakau Highway       | SH 6  |         |            | yes    |
+            | vbuq      | primary | 100      | Kumara Junction         |       |         | roundabout | yes    |
+            | jmv       | primary | 100      | Kumara Junction         |       |         | roundabout | yes    |
+            | fcpj      | primary | 100      | Kumara Junction         |       |         | roundabout | yes    |
+
+        When I route I should get
+            | waypoints | route           | turns                                                    |
+            | 1,2       | Taramakau Highway,Kumara Junction Highway,Kumara Junction Highway,Kumara Junction Highway | depart,Kumara Junction-exit-2,exit rotary slight left,arrive |
+

features/testbot/matching.feature

@@ -603,3 +603,193 @@ Feature: Basic Map Matching
         When I match I should get
             | trace | timestamps | code    |
             | ab1d  | 0 1 2 3    | NoMatch |
+
+    Scenario: Regression test - avoid collapsing legs of a tidied split trace
+        Given a grid size of 20 meters
+        Given the node map
+            """
+            a--b--f
+               |
+               |
+               e--c---d--g
+            """
+        Given the query options
+        | tidy | true |
+
+        And the ways
+            | nodes | oneway |
+            | abf   | no     |
+            | be    | no     |
+            | ecdg  | no     |
+
+        When I match I should get
+        | trace    | timestamps                                   | matchings  | code |
+        | abbecd   | 10 11 27 1516914902 1516914913 1516914952    | ab,ecd     | Ok   |
+
+    Scenario: Regression test - waypoints trimming too much geometry
+        # fixes bug in map matching collapsing that was dropping path geometries
+        # after segments that had 0 distance in internal route results
+        Given the node map
+            """
+            ad
+            |
+            |
+            |
+            |
+            |e   g
+            b--------------c
+            f              h
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+
+        Given the query options
+            | waypoints | 0;4   |
+            | overview  | full  |
+
+        When I match I should get
+            | trace    | geometry                           | code |
+            | defgh    | 1,1,1,0.999461,1.000674,0.999461   | Ok   |
+
+    @match @testbot
+    Scenario: Regression test - waypoints trimming too much geometry
+        Given the profile "testbot"
+        Given a grid size of 10 meters
+        Given the query options
+          | geometries | geojson |
+        Given the node map
+          """
+            bh
+             |
+             |
+             |
+             c
+             g\
+               \k
+                \
+                 \
+                  \
+                 j f
+          """
+        And the ways
+          | nodes |
+          | hc    |
+          | cf    |
+        Given the query options
+          | waypoints | 0;3  |
+          | overview  | full |
+        When I match I should get
+          | trace | geometry                                      | code |
+          | bgkj  | 1.000135,1,1.000135,0.99964,1.000387,0.999137 | Ok   |
+
+
+    @match @testbot
+    # Regression test for issue #4919
+    Scenario: Regression test - non-uturn maneuver preferred over uturn
+        Given the profile "testbot"
+        Given a grid size of 10 meters
+        Given the query options
+          | geometries | geojson |
+        Given the node map
+          """
+                e
+                ;
+                ;
+          a----hb-----c
+                ;
+                ;
+                d
+          """
+        And the ways
+          | nodes |
+          | abc   |
+          | dbe   |
+        Given the query options
+          | waypoints | 0;2  |
+          | overview  | full |
+          | steps     | true |
+        When I match I should get
+          | trace | geometry                                   | turns                    | code |
+          | abc   | 1,0.99973,1.00027,0.99973,1.000539,0.99973 | depart,arrive            | Ok   |
+          | abd   | 1,0.99973,1.00027,0.99973,1.00027,0.999461 | depart,turn right,arrive | Ok   |
+          | abe   | 1,0.99973,1.00027,0.99973,1.00027,1        | depart,turn left,arrive  | Ok   |
+          | ahd   | 1,0.99973,1.00027,0.99973,1.00027,0.999461 | depart,turn right,arrive | Ok   |
+          | ahe   | 1,0.99973,1.00027,0.99973,1.00027,1        | depart,turn left,arrive  | Ok   |
+
+    @match @testbot
+    Scenario: Regression test - add source phantoms properly (one phantom on one edge)
+        Given the profile "testbot"
+        Given a grid size of 10 meters
+        Given the node map
+          """
+          a--1-b2-cd3--e
+          """
+        And the ways
+          | nodes |
+          | ab    |
+          | bcd   |
+          | de    |
+        Given the query options
+          | geometries     | geojson         |
+          | overview       | full            |
+          | steps          | true            |
+          | waypoints      | 0;2             |
+          | annotations    | duration,weight |
+          | generate_hints | false           |
+        When I match I should get
+          | trace | geometry                                             | a:duration    | a:weight      | duration |
+          | 123   | 1.000135,1,1.000225,1,1.00036,1,1.000405,1,1.00045,1 | 1:1.5:0.5:0.5 | 1:1.5:0.5:0.5 | 3.5      |
+          | 321   | 1.00045,1,1.000405,1,1.00036,1,1.000225,1,1.000135,1 | 0.5:0.5:1.5:1 | 0.5:0.5:1.5:1 | 3.5      |
+
+    @match @testbot
+    Scenario: Regression test - add source phantom properly (two phantoms on one edge)
+        Given the profile "testbot"
+        Given a grid size of 10 meters
+        Given the node map
+          """
+          a--1-b23-c4--d
+          """
+        And the ways
+          | nodes |
+          | ab    |
+          | bc    |
+          | cd    |
+        Given the query options
+          | geometries     | geojson         |
+          | overview       | full            |
+          | steps          | true            |
+          | waypoints      | 0;3             |
+          | annotations    | duration,weight |
+          | generate_hints | false           |
+        When I match I should get
+          | trace | geometry                                   | a:duration | a:weight | duration |
+          | 1234  | 1.000135,1,1.000225,1,1.000405,1,1.00045,1 | 1:2:0.5    | 1:2:0.5  | 3.5      |
+          | 4321  | 1.00045,1,1.000405,1,1.000225,1,1.000135,1 | 0.5:2:1    | 0.5:2:1  | 3.5      |
+
+    @match @testbot
+    Scenario: Regression test - add source phantom properly (two phantoms on one edge)
+        Given the profile "testbot"
+        Given a grid size of 10 meters
+        Given the node map
+          """
+          a--12345-b
+          """
+        And the ways
+          | nodes |
+          | ab    |
+        Given the query options
+          | geometries     | geojson                  |
+          | overview       | full                     |
+          | steps          | true                     |
+          | waypoints      | 0;3                      |
+          | annotations    | duration,weight,distance |
+          | generate_hints | false                    |
+
+        # These should have the same weights/duration in either direction
+        When I match I should get
+          | trace | geometry             | a:distance | a:duration | a:weight | duration |
+          | 2345  | 1.00018,1,1.000315,1 | 15.013264  | 1.5        | 1.5      | 1.5      |
+          | 4321  | 1.00027,1,1.000135,1 | 15.013264  | 1.5        | 1.5      | 1.5      |

features/testbot/multi_level_routing.feature

@@ -106,6 +106,40 @@ Feature: Multi level routing
             | l | 144.7 |    60 |
             | o | 124.7 |     0 |
 
+
+        When I request a travel distance matrix I should get
+            |   |       a |       f |       l |         o |
+            | a |    0+-2 | 2287+-2 | 1443+-2 |   1243+-2 |
+            | f | 2284+-2 |    0+-2 | 1241+-2 |   1443+-2 |
+            | l | 1443+-2 | 1244+-2 |    0+-2 |    600+-2 |
+            | o | 1243+-2 | 1444+-2 |  600+-2 |      0+-2 |
+
+        When I request a travel distance matrix I should get
+            |   | a | f          | l          | o        |
+            | a | 0 | 2287.2+-2  | 1443+-2    | 1243+-2  |
+
+        When I request a travel distance matrix I should get
+            |   |         a |
+            | a |         0 |
+            | f | 2284.5+-2 |
+            | l |    1443.1 |
+            | o |      1243 |
+
+        When I request a travel distance matrix I should get
+            |   |    a |      f  |      l  |       o |
+            | a |    0 | 2287+-2 | 1443+-2 | 1243+-2 |
+            | o | 1243 | 1444+-2 |  600+-2 |    0+-2 |
+
+
+        When I request a travel distance matrix I should get
+            |   |         a |        o  |
+            | a |      0+-2 |   1243+-2 |
+            | f |   2284+-2 |   1443+-2 |
+            | l |   1443+-2 |    600+-2 |
+            | o |   1243+-2 |      0+-2 |
+
+
+
     Scenario: Testbot - Multi level routing: horizontal road
         Given the node map
             """

features/testbot/traffic_speeds.feature

@@ -48,13 +48,13 @@ Feature: Traffic - speeds
 
         When I route I should get
           | from | to | route       | speed   | weights              | a:datasources |
-          | a    | b  | ad,de,eb,eb | 30 km/h | 1275.7,400.4,378.2,0 | 1:0:0:0       |
+          | a    | b  | ad,de,eb,eb | 30 km/h | 1275.7,400.4,378.2,0 | 1:0:0         |
           | a    | c  | ad,dc,dc    | 31 km/h | 1275.7,956.8,0       | 1:0           |
-          | b    | c  | bc,bc       | 27 km/h | 741.5,0              | 1:0           |
-          | a    | d  | ad,ad       | 27 km/h | 1275.7,0             | 1:0           |
+          | b    | c  | bc,bc       | 27 km/h | 741.5,0              | 1             |
+          | a    | d  | ad,ad       | 27 km/h | 1275.7,0             | 1             |
           | d    | c  | dc,dc       | 36 km/h | 956.8,0              | 0             |
           | g    | b  | fb,fb       | 36 km/h | 164.7,0              | 0             |
-          | a    | g  | ad,df,fb,fb | 30 km/h | 1275.7,487.5,304.7,0 | 1:0:0         |
+          | a    | g  | ad,df,fb,fb | 30 km/h | 1295.7,487.5,304.7,0 | 1:0:0         |
 
 
     Scenario: Weighting based on speed file weights, ETA based on file durations
@@ -74,12 +74,12 @@ Feature: Traffic - speeds
 
         When I route I should get
           | from | to | route       | speed   | weights              | a:datasources |
-          | a    | b  | ad,de,eb,eb | 30 km/h | 1275.7,400.4,378.2,0 | 1:0:0:0       |
+          | a    | b  | ad,de,eb,eb | 30 km/h | 1275.7,400.4,378.2,0 | 1:0:0         |
           | a    | c  | ad,dc,dc    | 31 km/h | 1275.7,956.8,0       | 1:0           |
-          | b    | c  | bc,bc       | 27 km/h | 741.5,0              | 1:0           |
-          | a    | d  | ad,ad       | 27 km/h | 1275.7,0             | 1:0           |
+          | b    | c  | bc,bc       | 27 km/h | 741.5,0              | 1             |
+          | a    | d  | ad,ad       | 27 km/h | 1275.7,0             | 1             |
           | d    | c  | dc,dc       | 36 km/h | 956.8,0              | 0             |
-          | g    | b  | ab,ab       | 1 km/h  | 10010.4,0            | 1:0           |
+          | g    | b  | ab,ab       | 1 km/h  | 10010.4,0            | 1             |
           | a    | g  | ab,ab       | 1 km/h  | 10010.3,0            | 1             |
 
 
@@ -106,14 +106,14 @@ Feature: Traffic - speeds
 
         When I route I should get
           | from | to | route       | speed   | weights                  | a:datasources |
-          | a    | b  | ab,ab       | 1 km/h  | 20020.73,0               | 1:0           |
-          | a    | c  | ab,bc,bc    | 2 km/h  | 20020.73,741.51,0        | 1:1:0         |
-          | b    | c  | bc,bc       | 27 km/h | 741.51,0                 | 1:0           |
+          | a    | b  | ab,ab       | 1 km/h  | 20020.73,0               | 1             |
+          | a    | c  | ab,bc,bc    | 2 km/h  | 20020.73,741.51,0        | 1:1           |
+          | b    | c  | bc,bc       | 27 km/h | 741.51,0                 | 1             |
           | a    | d  | ab,eb,de,de | 2 km/h  | 20020.73,378.17,400.41,0 | 1:0:0         |
           | d    | c  | dc,dc       | 36 km/h | 956.8,0                  | 0             |
-          | g    | b  | ab,ab       | 1 km/h  | 10010.37,0               | 1:0           |
+          | g    | b  | ab,ab       | 1 km/h  | 10010.37,0               | 1             |
           | a    | g  | ab,ab       | 1 km/h  | 10010.36,0               | 1             |
-          | g    | a  | ab,ab       | 1 km/h  | 10010.36,0               | 1:1           |
+          | g    | a  | ab,ab       | 1 km/h  | 10010.36,0               | 1             |
 
 
     Scenario: Speeds that isolate a single node (a)
@@ -135,14 +135,14 @@ Feature: Traffic - speeds
           | annotations | true |
 
         When I route I should get
-          | from | to | route    | speed   | weights       | a:datasources |
-          | a    | b  | fb,fb    | 36 km/h | 329.4,0       | 0             |
-          | a    | c  | fb,bc,bc | 30 km/h | 329.4,741.5,0 | 0:1:0         |
-          | b    | c  | bc,bc    | 27 km/h | 741.5,0       | 1:0           |
-          | a    | d  | fb,df,df | 36 km/h | 140,487.5,0   | 0:0:0         |
-          | d    | c  | dc,dc    | 36 km/h | 956.8,0       | 0             |
-          | g    | b  | fb,fb    | 36 km/h | 164.7,0       | 0             |
-          | a    | g  | fb,fb    | 36 km/h | 164.7,0       | 0             |
+          | from | to | route    | speed   | weights       | a:datasources | a:speed | a:nodes|
+          | a    | b  | fb,fb    | 36 km/h | 329.4,0       | 0             | 10      | 6:2    |
+          | a    | c  | fb,bc,bc | 30 km/h | 329.4,741.5,0 | 0:1           | 10:7.5  | 6:2:3  |
+          | b    | c  | bc,bc    | 27 km/h | 741.5,0       | 1             | 7.5     | 2:3    |
+          | a    | d  | fb,df,df | 36 km/h | 140,487.5,0   | 0:0           | 10:10   | 2:6:4  |
+          | d    | c  | dc,dc    | 36 km/h | 956.8,0       | 0             | 10      | 4:3    |
+          | g    | b  | fb,fb    | 36 km/h | 164.7,0       | 0             | 10      | 6:2    |
+          | a    | g  | fb,fb    | 36 km/h | 164.7,0       | 0             | 10      | 6:2    |
 
 
     Scenario: Verify that negative values cause an error, they're not valid at all

features/testbot/weight.feature

@@ -53,8 +53,8 @@ Feature: Weight tests
 
         When I route I should get
             | waypoints | route   | distances | weights | times   | a:distance          | a:duration | a:weight | a:speed |
-            | s,t       | abc,abc | 20m,0m    | 2.1,0   | 2.1s,0s | 20.017685           | 3          | 3        | 6.7     |
-            | t,s       | abc,abc | 20m,0m    | 2.1,0   | 2.1s,0s | 20.017685           | 3.1        | 3.1      | 6.5     |
+            | s,t       | abc,abc | 20m,0m    | 2.1,0   | 2.1s,0s | 20.017685           | 2.1        | 2.1      | 9.5     |
+            | t,s       | abc,abc | 20m,0m    | 2.1,0   | 2.1s,0s | 20.017685           | 2.1        | 2.1      | 9.5     |
             | s,e       | abc,abc | 40m,0m    | 4.1,0   | 4.1s,0s | 30.026527:10.008842 | 3.1:1      | 3.1:1    | 9.7:10  |
             | e,s       | abc,abc | 40m,0m    | 4.1,0   | 4.1s,0s | 10.008842:30.026527 | 1:3.1      | 1:3.1    | 10:9.7  |
 

include/contractor/contracted_metric.hpp

@@ -0,0 +1,25 @@
+#ifndef OSMR_CONTRACTOR_CONTRACTED_METRIC_HPP
+#define OSMR_CONTRACTOR_CONTRACTED_METRIC_HPP
+
+#include "contractor/query_graph.hpp"
+
+namespace osrm
+{
+namespace contractor
+{
+
+namespace detail
+{
+template <storage::Ownership Ownership> struct ContractedMetric
+{
+    detail::QueryGraph<Ownership> graph;
+    std::vector<util::ViewOrVector<bool, Ownership>> edge_filter;
+};
+}
+
+using ContractedMetric = detail::ContractedMetric<storage::Ownership::Container>;
+using ContractedMetricView = detail::ContractedMetric<storage::Ownership::View>;
+}
+}
+
+#endif

include/contractor/files.hpp

@@ -1,12 +1,9 @@
 #ifndef OSRM_CONTRACTOR_FILES_HPP
 #define OSRM_CONTRACTOR_FILES_HPP
 
-#include "contractor/query_graph.hpp"
+#include "contractor/serialization.hpp"
 
-#include "util/serialization.hpp"
-
-#include "storage/io.hpp"
-#include "storage/serialization.hpp"
+#include <unordered_map>
 
 namespace osrm
 {
@@ -15,54 +12,44 @@ namespace contractor
 namespace files
 {
 // reads .osrm.hsgr file
-template <typename QueryGraphT, typename EdgeFilterT>
+template <typename ContractedMetricT>
 inline void readGraph(const boost::filesystem::path &path,
-                      unsigned &checksum,
-                      QueryGraphT &graph,
-                      std::vector<EdgeFilterT> &edge_filter)
+                      std::unordered_map<std::string, ContractedMetricT> &metrics,
+                      std::uint32_t &connectivity_checksum)
 {
-    static_assert(std::is_same<QueryGraphView, QueryGraphT>::value ||
-                      std::is_same<QueryGraph, QueryGraphT>::value,
-                  "graph must be of type QueryGraph<>");
-    static_assert(std::is_same<EdgeFilterT, std::vector<bool>>::value ||
-                      std::is_same<EdgeFilterT, util::vector_view<bool>>::value,
-                  "edge_filter must be a container of vector<bool> or vector_view<bool>");
+    static_assert(std::is_same<ContractedMetric, ContractedMetricT>::value ||
+                      std::is_same<ContractedMetricView, ContractedMetricT>::value,
+                  "metric must be of type ContractedMetric<>");
 
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
+    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
+    storage::tar::FileReader reader{path, fingerprint};
 
-    reader.ReadInto(checksum);
-    util::serialization::read(reader, graph);
-    auto count = reader.ReadElementCount64();
-    edge_filter.resize(count);
-    for (const auto index : util::irange<std::size_t>(0, count))
+    reader.ReadInto("/ch/connectivity_checksum", connectivity_checksum);
+
+    for (auto &pair : metrics)
     {
-        storage::serialization::read(reader, edge_filter[index]);
+        serialization::read(reader, "/ch/metrics/" + pair.first, pair.second);
     }
 }
 
 // writes .osrm.hsgr file
-template <typename QueryGraphT, typename EdgeFilterT>
+template <typename ContractedMetricT>
 inline void writeGraph(const boost::filesystem::path &path,
-                       unsigned checksum,
-                       const QueryGraphT &graph,
-                       const std::vector<EdgeFilterT> &edge_filter)
+                       const std::unordered_map<std::string, ContractedMetricT> &metrics,
+                       const std::uint32_t connectivity_checksum)
 {
-    static_assert(std::is_same<QueryGraphView, QueryGraphT>::value ||
-                      std::is_same<QueryGraph, QueryGraphT>::value,
-                  "graph must be of type QueryGraph<>");
-    static_assert(std::is_same<EdgeFilterT, std::vector<bool>>::value ||
-                      std::is_same<EdgeFilterT, util::vector_view<bool>>::value,
-                  "edge_filter must be a container of vector<bool> or vector_view<bool>");
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
+    static_assert(std::is_same<ContractedMetric, ContractedMetricT>::value ||
+                      std::is_same<ContractedMetricView, ContractedMetricT>::value,
+                  "metric must be of type ContractedMetric<>");
+    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
+    storage::tar::FileWriter writer{path, fingerprint};
 
-    writer.WriteOne(checksum);
-    util::serialization::write(writer, graph);
-    writer.WriteElementCount64(edge_filter.size());
-    for (const auto &filter : edge_filter)
+    writer.WriteElementCount64("/ch/connectivity_checksum", 1);
+    writer.WriteFrom("/ch/connectivity_checksum", connectivity_checksum);
+
+    for (const auto &pair : metrics)
     {
-        storage::serialization::write(writer, filter);
+        serialization::write(writer, "/ch/metrics/" + pair.first, pair.second);
     }
 }
 }

include/contractor/graph_contractor_adaptors.hpp

@@ -128,23 +128,24 @@ ContractorGraph toContractorGraph(NodeID number_of_nodes, InputEdgeContainer inp
 
 template <class Edge, typename GraphT> inline std::vector<Edge> toEdges(GraphT graph)
 {
-    std::vector<Edge> edges;
-    edges.reserve(graph.GetNumberOfEdges());
+    util::Log() << "Converting contracted graph with " << graph.GetNumberOfEdges()
+                << " to edge list (" << (graph.GetNumberOfEdges() * sizeof(Edge)) << " bytes)";
+    std::vector<Edge> edges(graph.GetNumberOfEdges());
 
-    util::UnbufferedLog log;
-    log << "Getting edges of minimized graph ";
-    util::Percent p(log, graph.GetNumberOfNodes());
-    const NodeID number_of_nodes = graph.GetNumberOfNodes();
-    if (graph.GetNumberOfNodes())
     {
-        Edge new_edge;
+        util::UnbufferedLog log;
+        log << "Getting edges of minimized graph ";
+        util::Percent p(log, graph.GetNumberOfNodes());
+        const NodeID number_of_nodes = graph.GetNumberOfNodes();
+        std::size_t edge_index = 0;
         for (const auto node : util::irange(0u, number_of_nodes))
         {
             p.PrintStatus(node);
             for (auto edge : graph.GetAdjacentEdgeRange(node))
             {
                 const NodeID target = graph.GetTarget(edge);
-                const ContractorGraph::EdgeData &data = graph.GetEdgeData(edge);
+                const auto &data = graph.GetEdgeData(edge);
+                auto &new_edge = edges[edge_index++];
                 new_edge.source = node;
                 new_edge.target = target;
                 BOOST_ASSERT_MSG(SPECIAL_NODEID != new_edge.target, "Target id invalid");
@@ -156,16 +157,12 @@ template <class Edge, typename GraphT> inline std::vector<Edge> toEdges(GraphT g
                                  "edge id invalid");
                 new_edge.data.forward = data.forward;
                 new_edge.data.backward = data.backward;
-                edges.push_back(new_edge);
             }
         }
+        BOOST_ASSERT(edge_index == edges.size());
     }
 
-    // sort and remove duplicates
     tbb::parallel_sort(edges.begin(), edges.end());
-    auto new_end = std::unique(edges.begin(), edges.end());
-    edges.resize(new_end - edges.begin());
-    edges.shrink_to_fit();
 
     return edges;
 }

include/contractor/serialization.hpp

@@ -0,0 +1,53 @@
+#ifndef OSRM_CONTRACTOR_SERIALIZATION_HPP
+#define OSRM_CONTRACTOR_SERIALIZATION_HPP
+
+#include "contractor/contracted_metric.hpp"
+
+#include "util/serialization.hpp"
+
+#include "storage/serialization.hpp"
+#include "storage/tar.hpp"
+
+namespace osrm
+{
+namespace contractor
+{
+namespace serialization
+{
+
+template <storage::Ownership Ownership>
+void write(storage::tar::FileWriter &writer,
+           const std::string &name,
+           const detail::ContractedMetric<Ownership> &metric)
+{
+    util::serialization::write(writer, name + "/contracted_graph", metric.graph);
+
+    writer.WriteElementCount64(name + "/exclude", metric.edge_filter.size());
+    for (const auto index : util::irange<std::size_t>(0, metric.edge_filter.size()))
+    {
+        storage::serialization::write(writer,
+                                      name + "/exclude/" + std::to_string(index) + "/edge_filter",
+                                      metric.edge_filter[index]);
+    }
+}
+
+template <storage::Ownership Ownership>
+void read(storage::tar::FileReader &reader,
+          const std::string &name,
+          detail::ContractedMetric<Ownership> &metric)
+{
+    util::serialization::read(reader, name + "/contracted_graph", metric.graph);
+
+    metric.edge_filter.resize(reader.ReadElementCount64(name + "/exclude"));
+    for (const auto index : util::irange<std::size_t>(0, metric.edge_filter.size()))
+    {
+        storage::serialization::read(reader,
+                                     name + "/exclude/" + std::to_string(index) + "/edge_filter",
+                                     metric.edge_filter[index]);
+    }
+}
+}
+}
+}
+
+#endif

include/customizer/cell_customizer.hpp

@@ -1,8 +1,8 @@
 #ifndef OSRM_CELLS_CUSTOMIZER_HPP
 #define OSRM_CELLS_CUSTOMIZER_HPP
 
-#include "partition/cell_storage.hpp"
-#include "partition/multi_level_partition.hpp"
+#include "partitioner/cell_storage.hpp"
+#include "partitioner/multi_level_partition.hpp"
 #include "util/query_heap.hpp"
 
 #include <tbb/enumerable_thread_specific.h>
@@ -29,12 +29,12 @@ class CellCustomizer
         util::QueryHeap<NodeID, NodeID, EdgeWeight, HeapData, util::ArrayStorage<NodeID, int>>;
     using HeapPtr = tbb::enumerable_thread_specific<Heap>;
 
-    CellCustomizer(const partition::MultiLevelPartition &partition) : partition(partition) {}
+    CellCustomizer(const partitioner::MultiLevelPartition &partition) : partition(partition) {}
 
     template <typename GraphT>
     void Customize(const GraphT &graph,
                    Heap &heap,
-                   const partition::CellStorage &cells,
+                   const partitioner::CellStorage &cells,
                    const std::vector<bool> &allowed_nodes,
                    CellMetric &metric,
                    LevelID level,
@@ -97,7 +97,7 @@ class CellCustomizer
 
     template <typename GraphT>
     void Customize(const GraphT &graph,
-                   const partition::CellStorage &cells,
+                   const partitioner::CellStorage &cells,
                    const std::vector<bool> &allowed_nodes,
                    CellMetric &metric) const
     {
@@ -121,7 +121,7 @@ class CellCustomizer
   private:
     template <typename GraphT>
     void RelaxNode(const GraphT &graph,
-                   const partition::CellStorage &cells,
+                   const partitioner::CellStorage &cells,
                    const std::vector<bool> &allowed_nodes,
                    const CellMetric &metric,
                    Heap &heap,
@@ -209,7 +209,7 @@ class CellCustomizer
         }
     }
 
-    const partition::MultiLevelPartition &partition;
+    const partitioner::MultiLevelPartition &partition;
 };
 }
 }

include/customizer/customizer_config.hpp

@@ -21,7 +21,8 @@ struct CustomizationConfig final : storage::IOConfig
                     ".osrm.partition",
                     ".osrm.cells",
                     ".osrm.ebg_nodes",
-                    ".osrm.properties"},
+                    ".osrm.properties",
+                    ".osrm.enw"},
                    {},
                    {".osrm.cell_metrics", ".osrm.mldgr"}),
           requested_num_threads(0)

include/customizer/edge_based_graph.hpp

@@ -2,8 +2,8 @@
 #define OSRM_CUSTOMIZE_EDGE_BASED_GRAPH_HPP
 
 #include "extractor/edge_based_edge.hpp"
-#include "partition/edge_based_graph.hpp"
-#include "partition/multi_level_graph.hpp"
+#include "partitioner/edge_based_graph.hpp"
+#include "partitioner/multi_level_graph.hpp"
 #include "util/static_graph.hpp"
 #include "util/typedefs.hpp"
 
@@ -16,27 +16,109 @@ namespace osrm
 namespace customizer
 {
 
-using EdgeBasedGraphEdgeData = partition::EdgeBasedGraphEdgeData;
-
-struct MultiLevelEdgeBasedGraph
-    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>
+struct EdgeBasedGraphEdgeData
 {
-    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
-    using Base::Base;
+    NodeID turn_id; // ID of the edge based node (node based edge)
 };
 
-struct MultiLevelEdgeBasedGraphView
-    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>
+template <typename EdgeDataT, storage::Ownership Ownership> class MultiLevelGraph;
+
+namespace serialization
 {
-    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
-    using Base::Base;
+template <typename EdgeDataT, storage::Ownership Ownership>
+void read(storage::tar::FileReader &reader,
+          const std::string &name,
+          MultiLevelGraph<EdgeDataT, Ownership> &graph);
+
+template <typename EdgeDataT, storage::Ownership Ownership>
+void write(storage::tar::FileWriter &writer,
+           const std::string &name,
+           const MultiLevelGraph<EdgeDataT, Ownership> &graph);
+}
+
+template <typename EdgeDataT, storage::Ownership Ownership>
+class MultiLevelGraph : public partitioner::MultiLevelGraph<EdgeDataT, Ownership>
+{
+  private:
+    using SuperT = partitioner::MultiLevelGraph<EdgeDataT, Ownership>;
+    using PartitionerGraphT = partitioner::MultiLevelGraph<partitioner::EdgeBasedGraphEdgeData,
+                                                           storage::Ownership::Container>;
+    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
+
+  public:
+    using NodeArrayEntry = typename SuperT::NodeArrayEntry;
+    using EdgeArrayEntry = typename SuperT::EdgeArrayEntry;
+    using EdgeOffset = typename SuperT::EdgeOffset;
+
+    MultiLevelGraph() = default;
+    MultiLevelGraph(MultiLevelGraph &&) = default;
+    MultiLevelGraph(const MultiLevelGraph &) = default;
+    MultiLevelGraph &operator=(MultiLevelGraph &&) = default;
+    MultiLevelGraph &operator=(const MultiLevelGraph &) = default;
+
+    MultiLevelGraph(PartitionerGraphT &&graph,
+                    Vector<EdgeWeight> node_weights_,
+                    Vector<EdgeDuration> node_durations_)
+        : node_weights(std::move(node_weights_)), node_durations(std::move(node_durations_))
+    {
+        util::ViewOrVector<PartitionerGraphT::EdgeArrayEntry, storage::Ownership::Container>
+            original_edge_array;
+
+        std::tie(SuperT::node_array,
+                 original_edge_array,
+                 SuperT::node_to_edge_offset,
+                 SuperT::connectivity_checksum) = std::move(graph).data();
+
+        SuperT::edge_array.reserve(original_edge_array.size());
+        for (const auto &edge : original_edge_array)
+        {
+            SuperT::edge_array.push_back({edge.target, {edge.data.turn_id}});
+            is_forward_edge.push_back(edge.data.forward);
+            is_backward_edge.push_back(edge.data.backward);
+        }
+    }
+
+    MultiLevelGraph(Vector<NodeArrayEntry> node_array_,
+                    Vector<EdgeArrayEntry> edge_array_,
+                    Vector<EdgeOffset> node_to_edge_offset_,
+                    Vector<EdgeWeight> node_weights_,
+                    Vector<EdgeDuration> node_durations_,
+                    Vector<bool> is_forward_edge_,
+                    Vector<bool> is_backward_edge_)
+        : SuperT(std::move(node_array_), std::move(edge_array_), std::move(node_to_edge_offset_)),
+          node_weights(std::move(node_weights_)), node_durations(std::move(node_durations_)),
+          is_forward_edge(is_forward_edge_), is_backward_edge(is_backward_edge_)
+    {
+    }
+
+    EdgeWeight GetNodeWeight(NodeID node) const { return node_weights[node]; }
+
+    EdgeWeight GetNodeDuration(NodeID node) const { return node_durations[node]; }
+
+    bool IsForwardEdge(EdgeID edge) const { return is_forward_edge[edge]; }
+
+    bool IsBackwardEdge(EdgeID edge) const { return is_backward_edge[edge]; }
+
+    friend void
+    serialization::read<EdgeDataT, Ownership>(storage::tar::FileReader &reader,
+                                              const std::string &name,
+                                              MultiLevelGraph<EdgeDataT, Ownership> &graph);
+    friend void
+    serialization::write<EdgeDataT, Ownership>(storage::tar::FileWriter &writer,
+                                               const std::string &name,
+                                               const MultiLevelGraph<EdgeDataT, Ownership> &graph);
+
+  protected:
+    Vector<EdgeWeight> node_weights;
+    Vector<EdgeDuration> node_durations;
+    Vector<bool> is_forward_edge;
+    Vector<bool> is_backward_edge;
 };
 
-struct StaticEdgeBasedGraphEdge : MultiLevelEdgeBasedGraph::InputEdge
-{
-    using Base = MultiLevelEdgeBasedGraph::InputEdge;
-    using Base::Base;
-};
+using MultiLevelEdgeBasedGraph =
+    MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
+using MultiLevelEdgeBasedGraphView =
+    MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
 }
 }
 

include/customizer/files.hpp

@@ -3,10 +3,12 @@
 
 #include "customizer/serialization.hpp"
 
-#include "storage/io.hpp"
+#include "storage/tar.hpp"
 
 #include "util/integer_range.hpp"
 
+#include <unordered_map>
+
 namespace osrm
 {
 namespace customizer
@@ -16,42 +18,94 @@ namespace files
 
 // reads .osrm.cell_metrics file
 template <typename CellMetricT>
-inline void readCellMetrics(const boost::filesystem::path &path, std::vector<CellMetricT> &metrics)
+inline void readCellMetrics(const boost::filesystem::path &path,
+                            std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
     static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
                       std::is_same<CellMetric, CellMetricT>::value,
                   "");
 
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
+    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
+    storage::tar::FileReader reader{path, fingerprint};
 
-    auto num_metrics = reader.ReadElementCount64();
-    metrics.resize(num_metrics);
-
-    for (auto &metric : metrics)
+    for (auto &pair : metrics)
     {
-        serialization::read(reader, metric);
+        const auto &metric_name = pair.first;
+        auto &metric_exclude_classes = pair.second;
+
+        auto prefix = "/mld/metrics/" + metric_name + "/exclude";
+        auto num_exclude_classes = reader.ReadElementCount64(prefix);
+        metric_exclude_classes.resize(num_exclude_classes);
+
+        auto id = 0;
+        for (auto &metric : metric_exclude_classes)
+        {
+            serialization::read(reader, prefix + "/" + std::to_string(id++), metric);
+        }
     }
 }
 
 // writes .osrm.cell_metrics file
 template <typename CellMetricT>
-inline void writeCellMetrics(const boost::filesystem::path &path,
-                             const std::vector<CellMetricT> &metrics)
+inline void
+writeCellMetrics(const boost::filesystem::path &path,
+                 const std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
     static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
                       std::is_same<CellMetric, CellMetricT>::value,
                   "");
 
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
+    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
+    storage::tar::FileWriter writer{path, fingerprint};
 
-    writer.WriteElementCount64(metrics.size());
-    for (const auto &metric : metrics)
+    for (const auto &pair : metrics)
     {
-        serialization::write(writer, metric);
+        const auto &metric_name = pair.first;
+        const auto &metric_exclude_classes = pair.second;
+
+        auto prefix = "/mld/metrics/" + metric_name + "/exclude";
+        writer.WriteElementCount64(prefix, metric_exclude_classes.size());
+
+        auto id = 0;
+        for (auto &exclude_metric : metric_exclude_classes)
+        {
+            serialization::write(writer, prefix + "/" + std::to_string(id++), exclude_metric);
+        }
     }
 }
+
+// reads .osrm.mldgr file
+template <typename MultiLevelGraphT>
+inline void readGraph(const boost::filesystem::path &path,
+                      MultiLevelGraphT &graph,
+                      std::uint32_t &connectivity_checksum)
+{
+    static_assert(std::is_same<customizer::MultiLevelEdgeBasedGraphView, MultiLevelGraphT>::value ||
+                      std::is_same<customizer::MultiLevelEdgeBasedGraph, MultiLevelGraphT>::value,
+                  "");
+
+    storage::tar::FileReader reader{path, storage::tar::FileReader::VerifyFingerprint};
+
+    reader.ReadInto("/mld/connectivity_checksum", connectivity_checksum);
+    serialization::read(reader, "/mld/multilevelgraph", graph);
+}
+
+// writes .osrm.mldgr file
+template <typename MultiLevelGraphT>
+inline void writeGraph(const boost::filesystem::path &path,
+                       const MultiLevelGraphT &graph,
+                       const std::uint32_t connectivity_checksum)
+{
+    static_assert(std::is_same<customizer::MultiLevelEdgeBasedGraphView, MultiLevelGraphT>::value ||
+                      std::is_same<customizer::MultiLevelEdgeBasedGraph, MultiLevelGraphT>::value,
+                  "");
+
+    storage::tar::FileWriter writer{path, storage::tar::FileWriter::GenerateFingerprint};
+
+    writer.WriteElementCount64("/mld/connectivity_checksum", 1);
+    writer.WriteFrom("/mld/connectivity_checksum", connectivity_checksum);
+    serialization::write(writer, "/mld/multilevelgraph", graph);
+}
 }
 }
 }

include/customizer/serialization.hpp

@@ -1,11 +1,13 @@
 #ifndef OSRM_CUSTOMIZER_SERIALIZATION_HPP
 #define OSRM_CUSTOMIZER_SERIALIZATION_HPP
 
-#include "partition/cell_storage.hpp"
+#include "customizer/edge_based_graph.hpp"
+
+#include "partitioner/cell_storage.hpp"
 
-#include "storage/io.hpp"
 #include "storage/serialization.hpp"
 #include "storage/shared_memory_ownership.hpp"
+#include "storage/tar.hpp"
 
 namespace osrm
 {
@@ -15,17 +17,49 @@ namespace serialization
 {
 
 template <storage::Ownership Ownership>
-inline void read(storage::io::FileReader &reader, detail::CellMetricImpl<Ownership> &metric)
+inline void read(storage::tar::FileReader &reader,
+                 const std::string &name,
+                 detail::CellMetricImpl<Ownership> &metric)
 {
-    storage::serialization::read(reader, metric.weights);
-    storage::serialization::read(reader, metric.durations);
+    storage::serialization::read(reader, name + "/weights", metric.weights);
+    storage::serialization::read(reader, name + "/durations", metric.durations);
 }
 
 template <storage::Ownership Ownership>
-inline void write(storage::io::FileWriter &writer, const detail::CellMetricImpl<Ownership> &metric)
+inline void write(storage::tar::FileWriter &writer,
+                  const std::string &name,
+                  const detail::CellMetricImpl<Ownership> &metric)
 {
-    storage::serialization::write(writer, metric.weights);
-    storage::serialization::write(writer, metric.durations);
+    storage::serialization::write(writer, name + "/weights", metric.weights);
+    storage::serialization::write(writer, name + "/durations", metric.durations);
+}
+
+template <typename EdgeDataT, storage::Ownership Ownership>
+inline void read(storage::tar::FileReader &reader,
+                 const std::string &name,
+                 MultiLevelGraph<EdgeDataT, Ownership> &graph)
+{
+    storage::serialization::read(reader, name + "/node_array", graph.node_array);
+    storage::serialization::read(reader, name + "/node_weights", graph.node_weights);
+    storage::serialization::read(reader, name + "/node_durations", graph.node_durations);
+    storage::serialization::read(reader, name + "/edge_array", graph.edge_array);
+    storage::serialization::read(reader, name + "/is_forward_edge", graph.is_forward_edge);
+    storage::serialization::read(reader, name + "/is_backward_edge", graph.is_backward_edge);
+    storage::serialization::read(reader, name + "/node_to_edge_offset", graph.node_to_edge_offset);
+}
+
+template <typename EdgeDataT, storage::Ownership Ownership>
+inline void write(storage::tar::FileWriter &writer,
+                  const std::string &name,
+                  const MultiLevelGraph<EdgeDataT, Ownership> &graph)
+{
+    storage::serialization::write(writer, name + "/node_array", graph.node_array);
+    storage::serialization::write(writer, name + "/node_weights", graph.node_weights);
+    storage::serialization::write(writer, name + "/node_durations", graph.node_durations);
+    storage::serialization::write(writer, name + "/edge_array", graph.edge_array);
+    storage::serialization::write(writer, name + "/is_forward_edge", graph.is_forward_edge);
+    storage::serialization::write(writer, name + "/is_backward_edge", graph.is_backward_edge);
+    storage::serialization::write(writer, name + "/node_to_edge_offset", graph.node_to_edge_offset);
 }
 }
 }

include/engine/algorithm.hpp

@@ -30,6 +30,11 @@ template <typename AlgorithmT> const char *name();
 template <> inline const char *name<ch::Algorithm>() { return "CH"; }
 template <> inline const char *name<mld::Algorithm>() { return "MLD"; }
 
+// Algorithm identifier
+template <typename AlgorithmT> const char *identifier();
+template <> inline const char *identifier<ch::Algorithm>() { return "ch"; }
+template <> inline const char *identifier<mld::Algorithm>() { return "mld"; }
+
 template <typename AlgorithmT> struct HasAlternativePathSearch final : std::false_type
 {
 };
@@ -45,6 +50,9 @@ template <typename AlgorithmT> struct HasMapMatching final : std::false_type
 template <typename AlgorithmT> struct HasManyToManySearch final : std::false_type
 {
 };
+template <typename AlgorithmT> struct SupportsDistanceAnnotationType final : std::false_type
+{
+};
 template <typename AlgorithmT> struct HasGetTileTurns final : std::false_type
 {
 };
@@ -68,6 +76,9 @@ template <> struct HasMapMatching<ch::Algorithm> final : std::true_type
 template <> struct HasManyToManySearch<ch::Algorithm> final : std::true_type
 {
 };
+template <> struct SupportsDistanceAnnotationType<ch::Algorithm> final : std::true_type
+{
+};
 template <> struct HasGetTileTurns<ch::Algorithm> final : std::true_type
 {
 };
@@ -91,6 +102,9 @@ template <> struct HasMapMatching<mld::Algorithm> final : std::true_type
 template <> struct HasManyToManySearch<mld::Algorithm> final : std::true_type
 {
 };
+template <> struct SupportsDistanceAnnotationType<mld::Algorithm> final : std::false_type
+{
+};
 template <> struct HasGetTileTurns<mld::Algorithm> final : std::true_type
 {
 };

include/engine/api/json_factory.hpp

@@ -1,8 +1,8 @@
 #ifndef ENGINE_RESPONSE_OBJECTS_HPP_
 #define ENGINE_RESPONSE_OBJECTS_HPP_
 
-#include "extractor/guidance/turn_instruction.hpp"
 #include "extractor/travel_mode.hpp"
+#include "guidance/turn_instruction.hpp"
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route.hpp"
 #include "engine/guidance/route_leg.hpp"

include/engine/api/match_api.hpp

@@ -87,9 +87,9 @@ class MatchAPI final : public RouteAPI
                      0u, static_cast<unsigned>(sub_matchings[sub_matching_index].indices.size())))
             {
                 // tidied_to_original: index of the input coordinate that a tidied coordinate
-                // corresponds to
+                // corresponds to.
                 // sub_matching indices: index of the coordinate passed to map matching plugin that
-                // a matched node corresponds to
+                // a matched node corresponds to.
                 trace_idx_to_matching_idx[tidy_result
                                               .tidied_to_original[sub_matchings[sub_matching_index]
                                                                       .indices[point_index]]] =
@@ -97,6 +97,8 @@ class MatchAPI final : public RouteAPI
             }
         }
 
+        BOOST_ASSERT(parameters.waypoints.empty() || sub_matchings.size() == 1);
+
         std::size_t was_waypoint_idx = 0;
         for (auto trace_index : util::irange<std::size_t>(0UL, parameters.coordinates.size()))
         {
@@ -115,17 +117,23 @@ class MatchAPI final : public RouteAPI
                 sub_matchings[matching_index.sub_matching_index].nodes[matching_index.point_index];
             auto waypoint = BaseAPI::MakeWaypoint(phantom);
             waypoint.values["matchings_index"] = matching_index.sub_matching_index;
+            waypoint.values["waypoint_index"] = matching_index.point_index;
             waypoint.values["alternatives_count"] =
                 sub_matchings[matching_index.sub_matching_index]
                     .alternatives_count[matching_index.point_index];
-            if (tidy_result.was_waypoint[trace_index])
+            // waypoint indices need to be adjusted if route legs were collapsed
+            // waypoint parameter assumes there is only one match object
+            if (!parameters.waypoints.empty())
             {
-                waypoint.values["waypoint_index"] = was_waypoint_idx;
-                was_waypoint_idx++;
-            }
-            else
-            {
-                waypoint.values["waypoint_index"] = util::json::Null();
+                if (tidy_result.was_waypoint[trace_index])
+                {
+                    waypoint.values["waypoint_index"] = was_waypoint_idx;
+                    was_waypoint_idx++;
+                }
+                else
+                {
+                    waypoint.values["waypoint_index"] = util::json::Null();
+                }
             }
             waypoints.values.push_back(std::move(waypoint));
         }

include/engine/api/match_parameters_tidy.hpp

@@ -48,12 +48,14 @@ inline Result keep_all(const MatchParameters &params)
 
     result.can_be_removed.resize(params.coordinates.size(), false);
     result.was_waypoint.resize(params.coordinates.size(), true);
+    // by default all input coordinates are treated as waypoints
     if (!params.waypoints.empty())
     {
         for (const auto p : params.waypoints)
         {
             result.was_waypoint.set(p, false);
         }
+        // logic is a little funny, uses inversion to set the bitfield
         result.was_waypoint.flip();
     }
     result.tidied_to_original.reserve(params.coordinates.size());

include/engine/api/nearest_api.hpp

@@ -34,56 +34,55 @@ class NearestAPI final : public BaseAPI
 
         util::json::Array waypoints;
         waypoints.values.resize(phantom_nodes.front().size());
-        std::transform(phantom_nodes.front().begin(),
-                       phantom_nodes.front().end(),
-                       waypoints.values.begin(),
-                       [this](const PhantomNodeWithDistance &phantom_with_distance) {
-                           auto &phantom_node = phantom_with_distance.phantom_node;
-                           auto waypoint = MakeWaypoint(phantom_node);
-                           waypoint.values["distance"] = phantom_with_distance.distance;
+        std::transform(
+            phantom_nodes.front().begin(),
+            phantom_nodes.front().end(),
+            waypoints.values.begin(),
+            [this](const PhantomNodeWithDistance &phantom_with_distance) {
+                auto &phantom_node = phantom_with_distance.phantom_node;
+                auto waypoint = MakeWaypoint(phantom_node);
+                waypoint.values["distance"] = phantom_with_distance.distance;
 
-                           util::json::Array nodes;
+                util::json::Array nodes;
 
-                           std::uint64_t from_node = 0;
-                           std::uint64_t to_node = 0;
+                std::uint64_t from_node = 0;
+                std::uint64_t to_node = 0;
 
-                           std::vector<NodeID> forward_geometry;
-                           if (phantom_node.forward_segment_id.enabled)
-                           {
-                               auto segment_id = phantom_node.forward_segment_id.id;
-                               const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
-                               forward_geometry =
-                                   facade.GetUncompressedForwardGeometry(geometry_id);
+                datafacade::BaseDataFacade::NodeForwardRange forward_geometry;
+                if (phantom_node.forward_segment_id.enabled)
+                {
+                    auto segment_id = phantom_node.forward_segment_id.id;
+                    const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
+                    forward_geometry = facade.GetUncompressedForwardGeometry(geometry_id);
 
-                               auto osm_node_id = facade.GetOSMNodeIDOfNode(
-                                   forward_geometry[phantom_node.fwd_segment_position]);
-                               to_node = static_cast<std::uint64_t>(osm_node_id);
-                           }
+                    auto osm_node_id = facade.GetOSMNodeIDOfNode(
+                        forward_geometry(phantom_node.fwd_segment_position));
+                    to_node = static_cast<std::uint64_t>(osm_node_id);
+                }
 
-                           if (phantom_node.reverse_segment_id.enabled)
-                           {
-                               auto segment_id = phantom_node.reverse_segment_id.id;
-                               const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
-                               std::vector<NodeID> geometry =
-                                   facade.GetUncompressedForwardGeometry(geometry_id);
-                               auto osm_node_id = facade.GetOSMNodeIDOfNode(
-                                   geometry[phantom_node.fwd_segment_position + 1]);
-                               from_node = static_cast<std::uint64_t>(osm_node_id);
-                           }
-                           else if (phantom_node.forward_segment_id.enabled &&
-                                    phantom_node.fwd_segment_position > 0)
-                           {
-                               // In the case of one way, rely on forward segment only
-                               auto osm_node_id = facade.GetOSMNodeIDOfNode(
-                                   forward_geometry[phantom_node.fwd_segment_position - 1]);
-                               from_node = static_cast<std::uint64_t>(osm_node_id);
-                           }
-                           nodes.values.push_back(from_node);
-                           nodes.values.push_back(to_node);
-                           waypoint.values["nodes"] = std::move(nodes);
+                if (phantom_node.reverse_segment_id.enabled)
+                {
+                    auto segment_id = phantom_node.reverse_segment_id.id;
+                    const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
+                    const auto geometry = facade.GetUncompressedForwardGeometry(geometry_id);
+                    auto osm_node_id =
+                        facade.GetOSMNodeIDOfNode(geometry(phantom_node.fwd_segment_position + 1));
+                    from_node = static_cast<std::uint64_t>(osm_node_id);
+                }
+                else if (phantom_node.forward_segment_id.enabled &&
+                         phantom_node.fwd_segment_position > 0)
+                {
+                    // In the case of one way, rely on forward segment only
+                    auto osm_node_id = facade.GetOSMNodeIDOfNode(
+                        forward_geometry(phantom_node.fwd_segment_position - 1));
+                    from_node = static_cast<std::uint64_t>(osm_node_id);
+                }
+                nodes.values.push_back(from_node);
+                nodes.values.push_back(to_node);
+                waypoint.values["nodes"] = std::move(nodes);
 
-                           return waypoint;
-                       });
+                return waypoint;
+            });
 
         response.values["code"] = "Ok";
         response.values["waypoints"] = std::move(waypoints);

include/engine/api/route_api.hpp

@@ -1,6 +1,7 @@
 #ifndef ENGINE_API_ROUTE_HPP
 #define ENGINE_API_ROUTE_HPP
 
+#include "extractor/maneuver_override.hpp"
 #include "engine/api/base_api.hpp"
 #include "engine/api/json_factory.hpp"
 #include "engine/api/route_parameters.hpp"
@@ -19,6 +20,8 @@
 
 #include "engine/internal_route_result.hpp"
 
+#include "guidance/turn_instruction.hpp"
+
 #include "util/coordinate.hpp"
 #include "util/integer_range.hpp"
 #include "util/json_util.hpp"
@@ -88,11 +91,12 @@ class RouteAPI : public BaseAPI
     {
         util::json::Array annotations_store;
         annotations_store.values.reserve(leg.annotations.size());
-        std::for_each(leg.annotations.begin(),
-                      leg.annotations.end(),
-                      [Get, &annotations_store](const auto &step) {
-                          annotations_store.values.push_back(Get(step));
-                      });
+
+        for (const auto &step : leg.annotations)
+        {
+            annotations_store.values.push_back(Get(step));
+        }
+
         return annotations_store;
     }
 
@@ -129,6 +133,7 @@ class RouteAPI : public BaseAPI
                                              reversed_target,
                                              parameters.steps);
 
+            util::Log(logDEBUG) << "Assembling steps " << std::endl;
             if (parameters.steps)
             {
                 auto steps = guidance::assembleSteps(BaseAPI::facade,
@@ -139,6 +144,13 @@ class RouteAPI : public BaseAPI
                                                      reversed_source,
                                                      reversed_target);
 
+                // Apply maneuver overrides before any other post
+                // processing is performed
+                guidance::applyOverrides(BaseAPI::facade, steps, leg_geometry);
+
+                // Collapse segregated steps before others
+                steps = guidance::collapseSegregatedTurnInstructions(std::move(steps));
+
                 /* Perform step-based post-processing.
                  *
                  * Using post-processing on basis of route-steps for a single leg at a time
@@ -202,12 +214,16 @@ class RouteAPI : public BaseAPI
         }
 
         std::vector<util::json::Value> step_geometries;
+        const auto total_step_count =
+            std::accumulate(legs.begin(), legs.end(), 0, [](const auto &v, const auto &leg) {
+                return v + leg.steps.size();
+            });
+        step_geometries.reserve(total_step_count);
+
         for (const auto idx : util::irange<std::size_t>(0UL, legs.size()))
         {
             auto &leg_geometry = leg_geometries[idx];
 
-            step_geometries.reserve(step_geometries.size() + legs[idx].steps.size());
-
             std::transform(
                 legs[idx].steps.begin(),
                 legs[idx].steps.end(),
@@ -255,10 +271,19 @@ class RouteAPI : public BaseAPI
                 // AnnotationsType uses bit flags, & operator checks if a property is set
                 if (parameters.annotations_type & RouteParameters::AnnotationsType::Speed)
                 {
+                    double prev_speed = 0;
                     annotation.values["speed"] = GetAnnotations(
-                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                            auto val = std::round(anno.distance / anno.duration * 10.) / 10.;
-                            return util::json::clamp_float(val);
+                        leg_geometry, [&prev_speed](const guidance::LegGeometry::Annotation &anno) {
+                            if (anno.duration < std::numeric_limits<double>::min())
+                            {
+                                return prev_speed;
+                            }
+                            else
+                            {
+                                auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
+                                prev_speed = speed;
+                                return util::json::clamp_float(speed);
+                            }
                         });
                 }
 
@@ -293,13 +318,29 @@ class RouteAPI : public BaseAPI
                 {
                     util::json::Array nodes;
                     nodes.values.reserve(leg_geometry.osm_node_ids.size());
-                    std::for_each(leg_geometry.osm_node_ids.begin(),
-                                  leg_geometry.osm_node_ids.end(),
-                                  [this, &nodes](const OSMNodeID &node_id) {
-                                      nodes.values.push_back(static_cast<std::uint64_t>(node_id));
-                                  });
+                    for (const auto node_id : leg_geometry.osm_node_ids)
+                    {
+                        nodes.values.push_back(static_cast<std::uint64_t>(node_id));
+                    }
                     annotation.values["nodes"] = std::move(nodes);
                 }
+                // Add any supporting metadata, if needed
+                if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
+                {
+                    const auto MAX_DATASOURCE_ID = 255u;
+                    util::json::Object metadata;
+                    util::json::Array datasource_names;
+                    for (auto i = 0u; i < MAX_DATASOURCE_ID; i++)
+                    {
+                        const auto name = facade.GetDatasourceName(i);
+                        // Length of 0 indicates the first empty name, so we can stop here
+                        if (name.size() == 0)
+                            break;
+                        datasource_names.values.push_back(std::string(facade.GetDatasourceName(i)));
+                    }
+                    metadata.values["datasource_names"] = datasource_names;
+                    annotation.values["metadata"] = metadata;
+                }
 
                 annotations.push_back(std::move(annotation));
             }

include/engine/api/table_api.hpp

@@ -36,9 +36,10 @@ class TableAPI final : public BaseAPI
     {
     }
 
-    virtual void MakeResponse(const std::vector<EdgeWeight> &durations,
-                              const std::vector<PhantomNode> &phantoms,
-                              util::json::Object &response) const
+    virtual void
+    MakeResponse(const std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>> &tables,
+                 const std::vector<PhantomNode> &phantoms,
+                 util::json::Object &response) const
     {
         auto number_of_sources = parameters.sources.size();
         auto number_of_destinations = parameters.destinations.size();
@@ -64,8 +65,18 @@ class TableAPI final : public BaseAPI
             response.values["destinations"] = MakeWaypoints(phantoms, parameters.destinations);
         }
 
-        response.values["durations"] =
-            MakeTable(durations, number_of_sources, number_of_destinations);
+        if (parameters.annotations & TableParameters::AnnotationsType::Duration)
+        {
+            response.values["durations"] =
+                MakeDurationTable(tables.first, number_of_sources, number_of_destinations);
+        }
+
+        if (parameters.annotations & TableParameters::AnnotationsType::Distance)
+        {
+            response.values["distances"] =
+                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations);
+        }
+
         response.values["code"] = "Ok";
     }
 
@@ -97,9 +108,9 @@ class TableAPI final : public BaseAPI
         return json_waypoints;
     }
 
-    virtual util::json::Array MakeTable(const std::vector<EdgeWeight> &values,
-                                        std::size_t number_of_rows,
-                                        std::size_t number_of_columns) const
+    virtual util::json::Array MakeDurationTable(const std::vector<EdgeWeight> &values,
+                                                std::size_t number_of_rows,
+                                                std::size_t number_of_columns) const
     {
         util::json::Array json_table;
         for (const auto row : util::irange<std::size_t>(0UL, number_of_rows))
@@ -116,6 +127,7 @@ class TableAPI final : public BaseAPI
                                {
                                    return util::json::Value(util::json::Null());
                                }
+                               // division by 10 because the duration is in deciseconds (10s)
                                return util::json::Value(util::json::Number(duration / 10.));
                            });
             json_table.values.push_back(std::move(json_row));
@@ -123,6 +135,34 @@ class TableAPI final : public BaseAPI
         return json_table;
     }
 
+    virtual util::json::Array MakeDistanceTable(const std::vector<EdgeDistance> &values,
+                                                std::size_t number_of_rows,
+                                                std::size_t number_of_columns) const
+    {
+        util::json::Array json_table;
+        for (const auto row : util::irange<std::size_t>(0UL, number_of_rows))
+        {
+            util::json::Array json_row;
+            auto row_begin_iterator = values.begin() + (row * number_of_columns);
+            auto row_end_iterator = values.begin() + ((row + 1) * number_of_columns);
+            json_row.values.resize(number_of_columns);
+            std::transform(row_begin_iterator,
+                           row_end_iterator,
+                           json_row.values.begin(),
+                           [](const EdgeDistance distance) {
+                               if (distance == INVALID_EDGE_DISTANCE)
+                               {
+                                   return util::json::Value(util::json::Null());
+                               }
+                               // round to single decimal place
+                               return util::json::Value(
+                                   util::json::Number(std::round(distance * 10) / 10.));
+                           });
+            json_table.values.push_back(std::move(json_row));
+        }
+        return json_table;
+    }
+
     const TableParameters &parameters;
 };
 

include/engine/api/table_parameters.hpp

@@ -60,6 +60,16 @@ struct TableParameters : public BaseParameters
     std::vector<std::size_t> sources;
     std::vector<std::size_t> destinations;
 
+    enum class AnnotationsType
+    {
+        None = 0,
+        Duration = 0x01,
+        Distance = 0x02,
+        All = Duration | Distance
+    };
+
+    AnnotationsType annotations = AnnotationsType::Duration;
+
     TableParameters() = default;
     template <typename... Args>
     TableParameters(std::vector<std::size_t> sources_,
@@ -70,6 +80,16 @@ struct TableParameters : public BaseParameters
     {
     }
 
+    template <typename... Args>
+    TableParameters(std::vector<std::size_t> sources_,
+                    std::vector<std::size_t> destinations_,
+                    const AnnotationsType annotations_,
+                    Args... args_)
+        : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
+          destinations{std::move(destinations_)}, annotations{annotations_}
+    {
+    }
+
     bool IsValid() const
     {
         if (!BaseParameters::IsValid())
@@ -79,7 +99,7 @@ struct TableParameters : public BaseParameters
         if (coordinates.size() < 2)
             return false;
 
-        // 1/ The user is able to specify duplicates in srcs and dsts, in that case it's her fault
+        // 1/ The user is able to specify duplicates in srcs and dsts, in that case it's their fault
 
         // 2/ len(srcs) and len(dsts) smaller or equal to len(locations)
         if (sources.size() > coordinates.size())
@@ -100,6 +120,26 @@ struct TableParameters : public BaseParameters
         return true;
     }
 };
+inline bool operator&(TableParameters::AnnotationsType lhs, TableParameters::AnnotationsType rhs)
+{
+    return static_cast<bool>(
+        static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(lhs) &
+        static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(rhs));
+}
+
+inline TableParameters::AnnotationsType operator|(TableParameters::AnnotationsType lhs,
+                                                  TableParameters::AnnotationsType rhs)
+{
+    return (TableParameters::AnnotationsType)(
+        static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(lhs) |
+        static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(rhs));
+}
+
+inline TableParameters::AnnotationsType &operator|=(TableParameters::AnnotationsType &lhs,
+                                                    TableParameters::AnnotationsType rhs)
+{
+    return lhs = lhs | rhs;
+}
 }
 }
 }

include/engine/base64.hpp

@@ -87,7 +87,7 @@ inline std::string encodeBase64(const std::string &x) { return encodeBase64(x.da
 // Encode any sufficiently trivial object to Base64.
 template <typename T> std::string encodeBase64Bytewise(const T &x)
 {
-#if not defined __GNUC__ or __GNUC__ > 4
+#if !defined(__GNUC__) || (__GNUC__ > 4)
     static_assert(std::is_trivially_copyable<T>::value, "requires a trivially copyable type");
 #endif
 
@@ -124,7 +124,7 @@ inline std::string decodeBase64(const std::string &encoded)
 // Decodes from Base 64 to any sufficiently trivial object.
 template <typename T> T decodeBase64Bytewise(const std::string &encoded)
 {
-#if not defined __GNUC__ or __GNUC__ > 4
+#if !defined(__GNUC__) || (__GNUC__ > 4)
     static_assert(std::is_trivially_copyable<T>::value, "requires a trivially copyable type");
 #endif
 

include/engine/data_watchdog.hpp

@@ -32,20 +32,35 @@ template <typename AlgorithmT, typename FacadeT> class DataWatchdogImpl;
 template <typename AlgorithmT>
 class DataWatchdogImpl<AlgorithmT, datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>> final
 {
-    using mutex_type = typename storage::SharedMonitor<storage::SharedDataTimestamp>::mutex_type;
+    using mutex_type = typename storage::SharedMonitor<storage::SharedRegionRegister>::mutex_type;
     using Facade = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
 
   public:
-    DataWatchdogImpl() : active(true), timestamp(0)
+    DataWatchdogImpl(const std::string &dataset_name) : dataset_name(dataset_name), active(true)
     {
         // create the initial facade before launching the watchdog thread
         {
             boost::interprocess::scoped_lock<mutex_type> current_region_lock(barrier.get_mutex());
 
+            auto &shared_register = barrier.data();
+            auto static_region_id = shared_register.Find(dataset_name + "/static");
+            auto updatable_region_id = shared_register.Find(dataset_name + "/updatable");
+            if (static_region_id == storage::SharedRegionRegister::INVALID_REGION_ID ||
+                updatable_region_id == storage::SharedRegionRegister::INVALID_REGION_ID)
+            {
+                throw util::exception("Could not find shared memory region for \"" + dataset_name +
+                                      "/data\". Did you run osrm-datastore?");
+            }
+            static_shared_region = &shared_register.GetRegion(static_region_id);
+            updatable_shared_region = &shared_register.GetRegion(updatable_region_id);
+            static_region = *static_shared_region;
+            updatable_region = *updatable_shared_region;
+
             facade_factory =
                 DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT>(
-                    std::make_shared<datafacade::SharedMemoryAllocator>(barrier.data().region));
-            timestamp = barrier.data().timestamp;
+                    std::make_shared<datafacade::SharedMemoryAllocator>(
+                        std::vector<storage::SharedRegionRegister::ShmKey>{
+                            static_region.shm_key, updatable_region.shm_key}));
         }
 
         watcher = std::thread(&DataWatchdogImpl::Run, this);
@@ -74,30 +89,46 @@ class DataWatchdogImpl<AlgorithmT, datafacade::ContiguousInternalMemoryDataFacad
         {
             boost::interprocess::scoped_lock<mutex_type> current_region_lock(barrier.get_mutex());
 
-            while (active && timestamp == barrier.data().timestamp)
+            while (active && static_region.timestamp == static_shared_region->timestamp &&
+                   updatable_region.timestamp == updatable_shared_region->timestamp)
             {
                 barrier.wait(current_region_lock);
             }
 
-            if (timestamp != barrier.data().timestamp)
+            if (!active)
+                break;
+
+            if (static_region.timestamp != static_shared_region->timestamp)
             {
-                auto region = barrier.data().region;
-                facade_factory =
-                    DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT>(
-                        std::make_shared<datafacade::SharedMemoryAllocator>(region));
-                timestamp = barrier.data().timestamp;
-                util::Log() << "updated facade to region " << region << " with timestamp "
-                            << timestamp;
+                static_region = *static_shared_region;
             }
+            if (updatable_region.timestamp != updatable_shared_region->timestamp)
+            {
+                updatable_region = *updatable_shared_region;
+            }
+
+            util::Log() << "updated facade to regions " << (int)static_region.shm_key << " and "
+                        << (int)updatable_region.shm_key << " with timestamps "
+                        << static_region.timestamp << " and " << updatable_region.timestamp;
+
+            facade_factory =
+                DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT>(
+                    std::make_shared<datafacade::SharedMemoryAllocator>(
+                        std::vector<storage::SharedRegionRegister::ShmKey>{
+                            static_region.shm_key, updatable_region.shm_key}));
         }
 
         util::Log() << "DataWatchdog thread stopped";
     }
 
-    storage::SharedMonitor<storage::SharedDataTimestamp> barrier;
+    const std::string dataset_name;
+    storage::SharedMonitor<storage::SharedRegionRegister> barrier;
     std::thread watcher;
     bool active;
-    unsigned timestamp;
+    storage::SharedRegion static_region;
+    storage::SharedRegion updatable_region;
+    storage::SharedRegion *static_shared_region;
+    storage::SharedRegion *updatable_shared_region;
     DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT> facade_factory;
 };
 }

include/engine/datafacade/algorithm_datafacade.hpp

@@ -2,11 +2,12 @@
 #define OSRM_ENGINE_DATAFACADE_ALGORITHM_DATAFACADE_HPP
 
 #include "contractor/query_edge.hpp"
+#include "customizer/edge_based_graph.hpp"
 #include "extractor/edge_based_edge.hpp"
 #include "engine/algorithm.hpp"
 
-#include "partition/cell_storage.hpp"
-#include "partition/multi_level_partition.hpp"
+#include "partitioner/cell_storage.hpp"
+#include "partitioner/multi_level_partition.hpp"
 
 #include "util/filtered_graph.hpp"
 #include "util/integer_range.hpp"
@@ -59,25 +60,35 @@ template <> class AlgorithmDataFacade<CH>
 template <> class AlgorithmDataFacade<MLD>
 {
   public:
-    using EdgeData = extractor::EdgeBasedEdge::EdgeData;
+    using EdgeData = customizer::EdgeBasedGraphEdgeData;
     using EdgeRange = util::range<EdgeID>;
 
     // search graph access
     virtual unsigned GetNumberOfNodes() const = 0;
 
+    virtual unsigned GetMaxBorderNodeID() const = 0;
+
     virtual unsigned GetNumberOfEdges() const = 0;
 
     virtual unsigned GetOutDegree(const NodeID n) const = 0;
 
+    virtual EdgeRange GetAdjacentEdgeRange(const NodeID node) const = 0;
+
+    virtual EdgeWeight GetNodeWeight(const NodeID node) const = 0;
+
+    virtual EdgeWeight GetNodeDuration(const NodeID node) const = 0; // TODO: to be removed
+
+    virtual bool IsForwardEdge(EdgeID edge) const = 0;
+
+    virtual bool IsBackwardEdge(EdgeID edge) const = 0;
+
     virtual NodeID GetTarget(const EdgeID e) const = 0;
 
     virtual const EdgeData &GetEdgeData(const EdgeID e) const = 0;
 
-    virtual EdgeRange GetAdjacentEdgeRange(const NodeID node) const = 0;
+    virtual const partitioner::MultiLevelPartitionView &GetMultiLevelPartition() const = 0;
 
-    virtual const partition::MultiLevelPartitionView &GetMultiLevelPartition() const = 0;
-
-    virtual const partition::CellStorageView &GetCellStorage() const = 0;
+    virtual const partitioner::CellStorageView &GetCellStorage() const = 0;
 
     virtual const customizer::CellMetricView &GetCellMetric() const = 0;
 

include/engine/datafacade/contiguous_block_allocator.hpp

@@ -1,7 +1,7 @@
 #ifndef OSRM_ENGINE_DATAFACADE_CONTIGUOUS_BLOCK_ALLOCATOR_HPP_
 #define OSRM_ENGINE_DATAFACADE_CONTIGUOUS_BLOCK_ALLOCATOR_HPP_
 
-#include "storage/shared_datatype.hpp"
+#include "storage/shared_data_index.hpp"
 
 namespace osrm
 {
@@ -16,8 +16,7 @@ class ContiguousBlockAllocator
     virtual ~ContiguousBlockAllocator() = default;
 
     // interface to give access to the datafacades
-    virtual storage::DataLayout &GetLayout() = 0;
-    virtual char *GetMemory() = 0;
+    virtual const storage::SharedDataIndex &GetIndex() = 0;
 };
 
 } // namespace datafacade

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -9,42 +9,13 @@
 #include "engine/approach.hpp"
 #include "engine/geospatial_query.hpp"
 
-#include "customizer/edge_based_graph.hpp"
-
-#include "extractor/datasources.hpp"
-#include "extractor/edge_based_node.hpp"
-#include "extractor/guidance/turn_instruction.hpp"
-#include "extractor/guidance/turn_lane_types.hpp"
-#include "extractor/intersection_bearings_container.hpp"
-#include "extractor/node_data_container.hpp"
-#include "extractor/packed_osm_ids.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 "storage/view_factory.hpp"
 
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
-#include "util/filtered_graph.hpp"
-#include "util/guidance/bearing_class.hpp"
-#include "util/guidance/entry_class.hpp"
-#include "util/guidance/turn_bearing.hpp"
-#include "util/guidance/turn_lanes.hpp"
 #include "util/log.hpp"
-#include "util/name_table.hpp"
-#include "util/packed_vector.hpp"
-#include "util/range_table.hpp"
-#include "util/rectangle.hpp"
-#include "util/static_graph.hpp"
-#include "util/static_rtree.hpp"
-#include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
 
@@ -79,44 +50,22 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
     // allocator that keeps the allocation data
     std::shared_ptr<ContiguousBlockAllocator> allocator;
 
-    void InitializeGraphPointer(storage::DataLayout &data_layout,
-                                char *memory_block,
-                                const std::size_t exclude_index)
-    {
-        auto graph_nodes_ptr = data_layout.GetBlockPtr<GraphNode>(
-            memory_block, storage::DataLayout::CH_GRAPH_NODE_LIST);
-
-        auto graph_edges_ptr = data_layout.GetBlockPtr<GraphEdge>(
-            memory_block, storage::DataLayout::CH_GRAPH_EDGE_LIST);
-
-        auto filter_block_id = static_cast<storage::DataLayout::BlockID>(
-            storage::DataLayout::CH_EDGE_FILTER_0 + exclude_index);
-
-        auto edge_filter_ptr = data_layout.GetBlockPtr<unsigned>(memory_block, filter_block_id);
-
-        util::vector_view<GraphNode> node_list(
-            graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::CH_GRAPH_NODE_LIST]);
-        util::vector_view<GraphEdge> edge_list(
-            graph_edges_ptr, data_layout.num_entries[storage::DataLayout::CH_GRAPH_EDGE_LIST]);
-
-        util::vector_view<bool> edge_filter(edge_filter_ptr,
-                                            data_layout.num_entries[filter_block_id]);
-        m_query_graph = QueryGraph({node_list, edge_list}, edge_filter);
-    }
-
   public:
     ContiguousInternalMemoryAlgorithmDataFacade(
-        std::shared_ptr<ContiguousBlockAllocator> allocator_, std::size_t exclude_index)
+        std::shared_ptr<ContiguousBlockAllocator> allocator_,
+        const std::string &metric_name,
+        std::size_t exclude_index)
         : allocator(std::move(allocator_))
     {
-        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), exclude_index);
+        InitializeInternalPointers(allocator->GetIndex(), metric_name, exclude_index);
     }
 
-    void InitializeInternalPointers(storage::DataLayout &data_layout,
-                                    char *memory_block,
+    void InitializeInternalPointers(const storage::SharedDataIndex &index,
+                                    const std::string &metric_name,
                                     const std::size_t exclude_index)
     {
-        InitializeGraphPointer(data_layout, memory_block, exclude_index);
+        m_query_graph =
+            make_filtered_graph_view(index, "/ch/metrics/" + metric_name, exclude_index);
     }
 
     // search graph access
@@ -184,33 +133,35 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     using RTreeNode = SharedRTree::TreeNode;
 
     extractor::ClassData exclude_mask;
-    std::string m_timestamp;
     extractor::ProfileProperties *m_profile_properties;
     extractor::Datasources *m_datasources;
 
-    unsigned m_check_sum;
+    std::uint32_t m_check_sum;
     util::vector_view<util::Coordinate> m_coordinate_list;
     extractor::PackedOSMIDsView m_osmnodeid_list;
     util::vector_view<std::uint32_t> m_lane_description_offsets;
-    util::vector_view<extractor::guidance::TurnLaneType::Mask> m_lane_description_masks;
+    util::vector_view<extractor::TurnLaneType::Mask> m_lane_description_masks;
     util::vector_view<TurnPenalty> m_turn_weight_penalties;
     util::vector_view<TurnPenalty> m_turn_duration_penalties;
     extractor::SegmentDataView segment_data;
-    extractor::TurnDataView turn_data;
     extractor::EdgeBasedNodeDataView edge_based_node_data;
+    guidance::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;
 
-    std::unique_ptr<SharedRTree> m_static_rtree;
+    util::vector_view<extractor::StorageManeuverOverride> m_maneuver_overrides;
+    util::vector_view<NodeID> m_maneuver_override_node_sequences;
+
+    SharedRTree m_static_rtree;
     std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
     boost::filesystem::path file_index_path;
 
     extractor::IntersectionBearingsView intersection_bearings_view;
 
-    util::NameTable m_name_table;
+    extractor::NameTableView m_name_table;
     // 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;
@@ -218,313 +169,62 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     // allocator that keeps the allocation data
     std::shared_ptr<ContiguousBlockAllocator> allocator;
 
-    void InitializeProfilePropertiesPointer(storage::DataLayout &data_layout,
-                                            char *memory_block,
-                                            const std::size_t exclude_index)
-    {
-        m_profile_properties = data_layout.GetBlockPtr<extractor::ProfileProperties>(
-            memory_block, storage::DataLayout::PROPERTIES);
-
-        exclude_mask = m_profile_properties->excludable_classes[exclude_index];
-    }
-
-    void InitializeTimestampPointer(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto timestamp_ptr =
-            data_layout.GetBlockPtr<char>(memory_block, storage::DataLayout::TIMESTAMP);
-        m_timestamp.resize(data_layout.GetBlockSize(storage::DataLayout::TIMESTAMP));
-        std::copy(timestamp_ptr,
-                  timestamp_ptr + data_layout.GetBlockSize(storage::DataLayout::TIMESTAMP),
-                  m_timestamp.begin());
-    }
-
-    void InitializeChecksumPointer(storage::DataLayout &data_layout, char *memory_block)
-    {
-        m_check_sum =
-            *data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::HSGR_CHECKSUM);
-        util::Log() << "set checksum: " << m_check_sum;
-    }
-
-    void InitializeRTreePointers(storage::DataLayout &data_layout, char *memory_block)
-    {
-        BOOST_ASSERT_MSG(!m_coordinate_list.empty(), "coordinates must be loaded before r-tree");
-
-        const auto file_index_ptr =
-            data_layout.GetBlockPtr<char>(memory_block, storage::DataLayout::FILE_INDEX_PATH);
-        file_index_path = boost::filesystem::path(file_index_ptr);
-        if (!boost::filesystem::exists(file_index_path))
-        {
-            util::Log(logDEBUG) << "Leaf file name " << file_index_path.string();
-            throw util::exception("Could not load " + file_index_path.string() +
-                                  "Is any data loaded into shared memory?" + SOURCE_REF);
-        }
-
-        auto tree_nodes_ptr =
-            data_layout.GetBlockPtr<RTreeNode>(memory_block, storage::DataLayout::R_SEARCH_TREE);
-        auto tree_level_sizes_ptr = data_layout.GetBlockPtr<std::uint64_t>(
-            memory_block, storage::DataLayout::R_SEARCH_TREE_LEVELS);
-        m_static_rtree.reset(
-            new SharedRTree(tree_nodes_ptr,
-                            data_layout.num_entries[storage::DataLayout::R_SEARCH_TREE],
-                            tree_level_sizes_ptr,
-                            data_layout.num_entries[storage::DataLayout::R_SEARCH_TREE_LEVELS],
-                            file_index_path,
-                            m_coordinate_list));
-        m_geospatial_query.reset(
-            new SharedGeospatialQuery(*m_static_rtree, m_coordinate_list, *this));
-    }
-
-    void InitializeNodeInformationPointers(storage::DataLayout &layout, char *memory_ptr)
-    {
-        const auto coordinate_list_ptr =
-            layout.GetBlockPtr<util::Coordinate>(memory_ptr, storage::DataLayout::COORDINATE_LIST);
-        m_coordinate_list.reset(coordinate_list_ptr,
-                                layout.num_entries[storage::DataLayout::COORDINATE_LIST]);
-
-        const auto osmnodeid_ptr = layout.GetBlockPtr<extractor::PackedOSMIDsView::block_type>(
-            memory_ptr, storage::DataLayout::OSM_NODE_ID_LIST);
-        m_osmnodeid_list = extractor::PackedOSMIDsView(
-            util::vector_view<extractor::PackedOSMIDsView::block_type>(
-                osmnodeid_ptr, layout.num_entries[storage::DataLayout::OSM_NODE_ID_LIST]),
-            // We (ab)use the number of coordinates here because we know we have the same amount of
-            // ids
-            layout.num_entries[storage::DataLayout::COORDINATE_LIST]);
-    }
-
-    void InitializeEdgeBasedNodeDataInformationPointers(storage::DataLayout &layout,
-                                                        char *memory_ptr)
-    {
-        const auto edge_based_node_list_ptr = layout.GetBlockPtr<extractor::EdgeBasedNode>(
-            memory_ptr, storage::DataLayout::EDGE_BASED_NODE_DATA_LIST);
-        util::vector_view<extractor::EdgeBasedNode> edge_based_node_data_list(
-            edge_based_node_list_ptr,
-            layout.num_entries[storage::DataLayout::EDGE_BASED_NODE_DATA_LIST]);
-
-        const auto annotation_data_list_ptr =
-            layout.GetBlockPtr<extractor::NodeBasedEdgeAnnotation>(
-                memory_ptr, storage::DataLayout::ANNOTATION_DATA_LIST);
-        util::vector_view<extractor::NodeBasedEdgeAnnotation> annotation_data(
-            annotation_data_list_ptr,
-            layout.num_entries[storage::DataLayout::ANNOTATION_DATA_LIST]);
-
-        edge_based_node_data = extractor::EdgeBasedNodeDataView(
-            std::move(edge_based_node_data_list), std::move(annotation_data));
-    }
-
-    void InitializeEdgeInformationPointers(storage::DataLayout &layout, char *memory_ptr)
-    {
-        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]);
-
-        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]);
-
-        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]);
-
-        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 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]);
-
-        turn_data = extractor::TurnDataView(std::move(turn_instructions),
-                                            std::move(lane_data_ids),
-                                            std::move(entry_class_ids),
-                                            std::move(pre_turn_bearings),
-                                            std::move(post_turn_bearings));
-    }
-
-    void InitializeNamePointers(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto name_data_ptr =
-            data_layout.GetBlockPtr<char>(memory_block, storage::DataLayout::NAME_CHAR_DATA);
-        const auto name_data_size = data_layout.num_entries[storage::DataLayout::NAME_CHAR_DATA];
-        m_name_table.reset(name_data_ptr, name_data_ptr + name_data_size);
-    }
-
-    void InitializeTurnLaneDescriptionsPointers(storage::DataLayout &data_layout,
-                                                char *memory_block)
-    {
-        auto offsets_ptr = data_layout.GetBlockPtr<std::uint32_t>(
-            memory_block, storage::DataLayout::LANE_DESCRIPTION_OFFSETS);
-        util::vector_view<std::uint32_t> 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(
-            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>(
-            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>(
-            turn_duration_penalties_ptr,
-            data_layout.num_entries[storage::DataLayout::TURN_DURATION_PENALTIES]);
-    }
-
-    void InitializeGeometryPointers(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto geometries_index_ptr =
-            data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::GEOMETRIES_INDEX);
-        util::vector_view<unsigned> geometry_begin_indices(
-            geometries_index_ptr, data_layout.num_entries[storage::DataLayout::GEOMETRIES_INDEX]);
-
-        auto num_entries = data_layout.num_entries[storage::DataLayout::GEOMETRIES_NODE_LIST];
-        auto geometries_node_list_ptr = data_layout.GetBlockPtr<NodeID>(
-            memory_block, storage::DataLayout::GEOMETRIES_NODE_LIST);
-        util::vector_view<NodeID> geometry_node_list(geometries_node_list_ptr, num_entries);
-
-        auto geometries_fwd_weight_list_ptr =
-            data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentWeightVector::block_type>(
-                memory_block, storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST);
-        extractor::SegmentDataView::SegmentWeightVector geometry_fwd_weight_list(
-            util::vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
-                geometries_fwd_weight_list_ptr,
-                data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST]),
-            num_entries);
-
-        auto geometries_rev_weight_list_ptr =
-            data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentWeightVector::block_type>(
-                memory_block, storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST);
-        extractor::SegmentDataView::SegmentWeightVector geometry_rev_weight_list(
-            util::vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
-                geometries_rev_weight_list_ptr,
-                data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST]),
-            num_entries);
-
-        auto geometries_fwd_duration_list_ptr =
-            data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentDurationVector::block_type>(
-                memory_block, storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST);
-        extractor::SegmentDataView::SegmentDurationVector geometry_fwd_duration_list(
-            util::vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
-                geometries_fwd_duration_list_ptr,
-                data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST]),
-            num_entries);
-
-        auto geometries_rev_duration_list_ptr =
-            data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentDurationVector::block_type>(
-                memory_block, storage::DataLayout::GEOMETRIES_REV_DURATION_LIST);
-        extractor::SegmentDataView::SegmentDurationVector geometry_rev_duration_list(
-            util::vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
-                geometries_rev_duration_list_ptr,
-                data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_DURATION_LIST]),
-            num_entries);
-
-        auto geometries_fwd_datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
-            memory_block, storage::DataLayout::GEOMETRIES_FWD_DATASOURCES_LIST);
-        util::vector_view<DatasourceID> geometry_fwd_datasources_list(
-            geometries_fwd_datasources_list_ptr,
-            data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_DATASOURCES_LIST]);
-
-        auto geometries_rev_datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
-            memory_block, storage::DataLayout::GEOMETRIES_REV_DATASOURCES_LIST);
-        util::vector_view<DatasourceID> geometry_rev_datasources_list(
-            geometries_rev_datasources_list_ptr,
-            data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_DATASOURCES_LIST]);
-
-        segment_data = extractor::SegmentDataView{std::move(geometry_begin_indices),
-                                                  std::move(geometry_node_list),
-                                                  std::move(geometry_fwd_weight_list),
-                                                  std::move(geometry_rev_weight_list),
-                                                  std::move(geometry_fwd_duration_list),
-                                                  std::move(geometry_rev_duration_list),
-                                                  std::move(geometry_fwd_datasources_list),
-                                                  std::move(geometry_rev_datasources_list)};
-
-        m_datasources = data_layout.GetBlockPtr<extractor::Datasources>(
-            memory_block, storage::DataLayout::DATASOURCES_NAMES);
-    }
-
-    void InitializeIntersectionClassPointers(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto bearing_class_id_ptr = data_layout.GetBlockPtr<BearingClassID>(
-            memory_block, storage::DataLayout::BEARING_CLASSID);
-        util::vector_view<BearingClassID> bearing_class_id(
-            bearing_class_id_ptr, data_layout.num_entries[storage::DataLayout::BEARING_CLASSID]);
-
-        auto bearing_values_ptr = data_layout.GetBlockPtr<DiscreteBearing>(
-            memory_block, storage::DataLayout::BEARING_VALUES);
-        util::vector_view<DiscreteBearing> bearing_values(
-            bearing_values_ptr, data_layout.num_entries[storage::DataLayout::BEARING_VALUES]);
-
-        auto offsets_ptr =
-            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(
-            offsets_ptr, data_layout.num_entries[storage::DataLayout::BEARING_OFFSETS]);
-        util::vector_view<IndexBlock> bearing_blocks(
-            blocks_ptr, data_layout.num_entries[storage::DataLayout::BEARING_BLOCKS]);
-
-        util::RangeTable<16, storage::Ownership::View> bearing_range_table(
-            bearing_offsets, bearing_blocks, static_cast<unsigned>(bearing_values.size()));
-
-        intersection_bearings_view = extractor::IntersectionBearingsView{
-            std::move(bearing_values), std::move(bearing_class_id), std::move(bearing_range_table)};
-
-        auto entry_class_ptr = data_layout.GetBlockPtr<util::guidance::EntryClass>(
-            memory_block, storage::DataLayout::ENTRY_CLASS);
-        util::vector_view<util::guidance::EntryClass> entry_class_table(
-            entry_class_ptr, data_layout.num_entries[storage::DataLayout::ENTRY_CLASS]);
-        m_entry_class_table = std::move(entry_class_table);
-    }
-
-    void InitializeInternalPointers(storage::DataLayout &data_layout,
-                                    char *memory_block,
+    void InitializeInternalPointers(const storage::SharedDataIndex &index,
+                                    const std::string &metric_name,
                                     const std::size_t exclude_index)
     {
-        InitializeChecksumPointer(data_layout, memory_block);
-        InitializeNodeInformationPointers(data_layout, memory_block);
-        InitializeEdgeBasedNodeDataInformationPointers(data_layout, memory_block);
-        InitializeEdgeInformationPointers(data_layout, memory_block);
-        InitializeTurnPenalties(data_layout, memory_block);
-        InitializeGeometryPointers(data_layout, memory_block);
-        InitializeTimestampPointer(data_layout, memory_block);
-        InitializeNamePointers(data_layout, memory_block);
-        InitializeTurnLaneDescriptionsPointers(data_layout, memory_block);
-        InitializeProfilePropertiesPointer(data_layout, memory_block, exclude_index);
-        InitializeRTreePointers(data_layout, memory_block);
-        InitializeIntersectionClassPointers(data_layout, memory_block);
+        // TODO: For multi-metric support we need to have separate exclude classes per metric
+        (void)metric_name;
+
+        m_profile_properties =
+            index.GetBlockPtr<extractor::ProfileProperties>("/common/properties");
+
+        exclude_mask = m_profile_properties->excludable_classes[exclude_index];
+
+        m_check_sum = *index.GetBlockPtr<std::uint32_t>("/common/connectivity_checksum");
+
+        std::tie(m_coordinate_list, m_osmnodeid_list) =
+            make_nbn_data_view(index, "/common/nbn_data");
+
+        m_static_rtree = make_search_tree_view(index, "/common/rtree");
+        m_geospatial_query.reset(
+            new SharedGeospatialQuery(m_static_rtree, m_coordinate_list, *this));
+
+        edge_based_node_data = make_ebn_data_view(index, "/common/ebg_node_data");
+
+        turn_data = make_turn_data_view(index, "/common/turn_data");
+
+        m_name_table = make_name_table_view(index, "/common/names");
+
+        std::tie(m_lane_description_offsets, m_lane_description_masks) =
+            make_turn_lane_description_views(index, "/common/turn_lanes");
+        m_lane_tupel_id_pairs = make_lane_data_view(index, "/common/turn_lanes");
+
+        m_turn_weight_penalties = make_turn_weight_view(index, "/common/turn_penalty");
+        m_turn_duration_penalties = make_turn_duration_view(index, "/common/turn_penalty");
+
+        segment_data = make_segment_data_view(index, "/common/segment_data");
+
+        m_datasources = index.GetBlockPtr<extractor::Datasources>("/common/data_sources_names");
+
+        intersection_bearings_view =
+            make_intersection_bearings_view(index, "/common/intersection_bearings");
+
+        m_entry_class_table = make_entry_classes_view(index, "/common/entry_classes");
+
+        std::tie(m_maneuver_overrides, m_maneuver_override_node_sequences) =
+            make_maneuver_overrides_views(index, "/common/maneuver_overrides");
     }
 
   public:
     // allows switching between process_memory/shared_memory datafacade, based on the type of
     // allocator
     ContiguousInternalMemoryDataFacadeBase(std::shared_ptr<ContiguousBlockAllocator> allocator_,
+                                           const std::string &metric_name,
                                            const std::size_t exclude_index)
         : allocator(std::move(allocator_))
     {
-        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), exclude_index);
+        InitializeInternalPointers(allocator->GetIndex(), metric_name, exclude_index);
     }
 
     // node and edge information access
@@ -538,78 +238,63 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return m_osmnodeid_list[id];
     }
 
-    std::vector<NodeID> GetUncompressedForwardGeometry(const EdgeID id) const override final
+    NodeForwardRange GetUncompressedForwardGeometry(const EdgeID id) const override final
     {
-
-        auto range = segment_data.GetForwardGeometry(id);
-        return std::vector<NodeID>{range.begin(), range.end()};
+        return segment_data.GetForwardGeometry(id);
     }
 
-    virtual std::vector<NodeID> GetUncompressedReverseGeometry(const EdgeID id) const override final
+    NodeReverseRange GetUncompressedReverseGeometry(const EdgeID id) const override final
     {
-        auto range = segment_data.GetReverseGeometry(id);
-        return std::vector<NodeID>{range.begin(), range.end()};
+        return segment_data.GetReverseGeometry(id);
     }
 
-    virtual std::vector<EdgeWeight>
-    GetUncompressedForwardDurations(const EdgeID id) const override final
+    DurationForwardRange GetUncompressedForwardDurations(const EdgeID id) const override final
     {
-        auto range = segment_data.GetForwardDurations(id);
-        return std::vector<EdgeWeight>{range.begin(), range.end()};
+        return segment_data.GetForwardDurations(id);
     }
 
-    virtual std::vector<EdgeWeight>
-    GetUncompressedReverseDurations(const EdgeID id) const override final
+    DurationReverseRange GetUncompressedReverseDurations(const EdgeID id) const override final
     {
-        auto range = segment_data.GetReverseDurations(id);
-        return std::vector<EdgeWeight>{range.begin(), range.end()};
+        return segment_data.GetReverseDurations(id);
     }
 
-    virtual std::vector<EdgeWeight>
-    GetUncompressedForwardWeights(const EdgeID id) const override final
+    WeightForwardRange GetUncompressedForwardWeights(const EdgeID id) const override final
     {
-        auto range = segment_data.GetForwardWeights(id);
-        return std::vector<EdgeWeight>{range.begin(), range.end()};
+        return segment_data.GetForwardWeights(id);
     }
 
-    virtual std::vector<EdgeWeight>
-    GetUncompressedReverseWeights(const EdgeID id) const override final
+    WeightReverseRange GetUncompressedReverseWeights(const EdgeID id) const override final
     {
-        auto range = segment_data.GetReverseWeights(id);
-        return std::vector<EdgeWeight>{range.begin(), range.end()};
+        return segment_data.GetReverseWeights(id);
     }
 
     // Returns the data source ids that were used to supply the edge
     // weights.
-    virtual std::vector<DatasourceID>
-    GetUncompressedForwardDatasources(const EdgeID id) const override final
+    DatasourceForwardRange GetUncompressedForwardDatasources(const EdgeID id) const override final
     {
-        auto range = segment_data.GetForwardDatasources(id);
-        return std::vector<DatasourceID>{range.begin(), range.end()};
+        return segment_data.GetForwardDatasources(id);
     }
 
     // Returns the data source ids that were used to supply the edge
     // weights.
-    virtual std::vector<DatasourceID>
-    GetUncompressedReverseDatasources(const EdgeID id) const override final
+    DatasourceReverseRange GetUncompressedReverseDatasources(const EdgeID id) const override final
     {
-        auto range = segment_data.GetReverseDatasources(id);
-        return std::vector<DatasourceID>{range.begin(), range.end()};
+        return segment_data.GetReverseDatasources(id);
     }
 
-    virtual TurnPenalty GetWeightPenaltyForEdgeID(const unsigned id) const override final
+    TurnPenalty GetWeightPenaltyForEdgeID(const EdgeID id) const override final
     {
         BOOST_ASSERT(m_turn_weight_penalties.size() > id);
         return m_turn_weight_penalties[id];
     }
 
-    virtual TurnPenalty GetDurationPenaltyForEdgeID(const unsigned id) const override final
+    TurnPenalty GetDurationPenaltyForEdgeID(const EdgeID id) const override final
     {
         BOOST_ASSERT(m_turn_duration_penalties.size() > id);
         return m_turn_duration_penalties[id];
     }
 
-    extractor::guidance::TurnInstruction
+    osrm::guidance::TurnInstruction
     GetTurnInstructionForEdgeID(const EdgeID id) const override final
     {
         return turn_data.GetTurnInstruction(id);
@@ -743,7 +428,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
             input_coordinate, bearing, bearing_range, approach);
     }
 
-    unsigned GetCheckSum() const override final { return m_check_sum; }
+    std::uint32_t GetCheckSum() const override final { return m_check_sum; }
 
     GeometryID GetGeometryIndex(const NodeID id) const override final
     {
@@ -816,8 +501,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return m_datasources->GetSourceName(id);
     }
 
-    std::string GetTimestamp() const override final { return m_timestamp; }
-
     bool GetContinueStraightDefault() const override final
     {
         return m_profile_properties->continue_straight_at_waypoint;
@@ -845,11 +528,11 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return intersection_bearings_view.GetBearingClass(node);
     }
 
-    util::guidance::TurnBearing PreTurnBearing(const EdgeID eid) const override final
+    guidance::TurnBearing PreTurnBearing(const EdgeID eid) const override final
     {
         return turn_data.GetPreTurnBearing(eid);
     }
-    util::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const override final
+    guidance::TurnBearing PostTurnBearing(const EdgeID eid) const override final
     {
         return turn_data.GetPostTurnBearing(eid);
     }
@@ -868,13 +551,13 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return m_lane_tupel_id_pairs.at(turn_data.GetLaneDataID(id));
     }
 
-    extractor::guidance::TurnLaneDescription
+    extractor::TurnLaneDescription
     GetTurnDescription(const LaneDescriptionID lane_description_id) const override final
     {
         if (lane_description_id == INVALID_LANE_DESCRIPTIONID)
             return {};
         else
-            return extractor::guidance::TurnLaneDescription(
+            return extractor::TurnLaneDescription(
                 m_lane_description_masks.begin() + m_lane_description_offsets[lane_description_id],
                 m_lane_description_masks.begin() +
                     m_lane_description_offsets[lane_description_id + 1]);
@@ -890,6 +573,39 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         return edge_based_node_data.IsSegregated(id);
     }
+
+    std::vector<extractor::ManeuverOverride>
+    GetOverridesThatStartAt(const NodeID edge_based_node_id) const override final
+    {
+        std::vector<extractor::ManeuverOverride> results;
+
+        // heterogeneous comparison:
+        struct Comp
+        {
+            bool operator()(const extractor::StorageManeuverOverride &s, NodeID i) const
+            {
+                return s.start_node < i;
+            }
+            bool operator()(NodeID i, const extractor::StorageManeuverOverride &s) const
+            {
+                return i < s.start_node;
+            }
+        };
+
+        auto found_range = std::equal_range(
+            m_maneuver_overrides.begin(), m_maneuver_overrides.end(), edge_based_node_id, Comp{});
+
+        std::for_each(found_range.first, found_range.second, [&](const auto & override) {
+            std::vector<NodeID> sequence(
+                m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_begin,
+                m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_end);
+            results.push_back(extractor::ManeuverOverride{std::move(sequence),
+                                                          override.instruction_node,
+                                                          override.override_type,
+                                                          override.direction});
+        });
+        return results;
+    }
 };
 
 template <typename AlgorithmT> class ContiguousInternalMemoryDataFacade;
@@ -901,10 +617,10 @@ class ContiguousInternalMemoryDataFacade<CH>
 {
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator,
+                                       const std::string &metric_name,
                                        const std::size_t exclude_index)
-        : ContiguousInternalMemoryDataFacadeBase(allocator, exclude_index),
-          ContiguousInternalMemoryAlgorithmDataFacade<CH>(allocator, exclude_index)
-
+        : ContiguousInternalMemoryDataFacadeBase(allocator, metric_name, exclude_index),
+          ContiguousInternalMemoryAlgorithmDataFacade<CH>(allocator, metric_name, exclude_index)
     {
     }
 };
@@ -912,8 +628,8 @@ class ContiguousInternalMemoryDataFacade<CH>
 template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public AlgorithmDataFacade<MLD>
 {
     // MLD data
-    partition::MultiLevelPartitionView mld_partition;
-    partition::CellStorageView mld_cell_storage;
+    partitioner::MultiLevelPartitionView mld_partition;
+    partitioner::CellStorageView mld_cell_storage;
     customizer::CellMetricView mld_cell_metric;
     using QueryGraph = customizer::MultiLevelEdgeBasedGraphView;
     using GraphNode = QueryGraph::NodeArrayEntry;
@@ -921,122 +637,15 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
 
     QueryGraph query_graph;
 
-    void InitializeInternalPointers(storage::DataLayout &data_layout,
-                                    char *memory_block,
+    void InitializeInternalPointers(const storage::SharedDataIndex &index,
+                                    const std::string &metric_name,
                                     const std::size_t exclude_index)
     {
-        InitializeMLDDataPointers(data_layout, memory_block, exclude_index);
-        InitializeGraphPointer(data_layout, memory_block);
-    }
-
-    void InitializeMLDDataPointers(storage::DataLayout &data_layout,
-                                   char *memory_block,
-                                   const std::size_t exclude_index)
-    {
-        if (data_layout.GetBlockSize(storage::DataLayout::MLD_PARTITION) > 0)
-        {
-            BOOST_ASSERT(data_layout.GetBlockSize(storage::DataLayout::MLD_LEVEL_DATA) > 0);
-            BOOST_ASSERT(data_layout.GetBlockSize(storage::DataLayout::MLD_CELL_TO_CHILDREN) > 0);
-
-            auto level_data =
-                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);
-
-            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);
-
-            mld_partition =
-                partition::MultiLevelPartitionView{level_data, partition, cell_to_children};
-        }
-
-        const auto weights_block_id = static_cast<storage::DataLayout::BlockID>(
-            storage::DataLayout::MLD_CELL_WEIGHTS_0 + exclude_index);
-        const auto durations_block_id = static_cast<storage::DataLayout::BlockID>(
-            storage::DataLayout::MLD_CELL_DURATIONS_0 + exclude_index);
-
-        if (data_layout.GetBlockSize(weights_block_id) > 0)
-        {
-            auto mld_cell_weights_ptr =
-                data_layout.GetBlockPtr<EdgeWeight>(memory_block, weights_block_id);
-            auto mld_cell_durations_ptr =
-                data_layout.GetBlockPtr<EdgeDuration>(memory_block, durations_block_id);
-            auto weight_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_WEIGHTS_0);
-            auto duration_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_DURATIONS_0);
-            BOOST_ASSERT(weight_entries_count == duration_entries_count);
-            util::vector_view<EdgeWeight> weights(mld_cell_weights_ptr, weight_entries_count);
-            util::vector_view<EdgeDuration> durations(mld_cell_durations_ptr,
-                                                      duration_entries_count);
-
-            mld_cell_metric = customizer::CellMetricView{std::move(weights), std::move(durations)};
-        }
-
-        if (data_layout.GetBlockSize(storage::DataLayout::MLD_CELLS) > 0)
-        {
-
-            auto mld_source_boundary_ptr = data_layout.GetBlockPtr<NodeID>(
-                memory_block, storage::DataLayout::MLD_CELL_SOURCE_BOUNDARY);
-            auto mld_destination_boundary_ptr = data_layout.GetBlockPtr<NodeID>(
-                memory_block, storage::DataLayout::MLD_CELL_DESTINATION_BOUNDARY);
-            auto mld_cells_ptr = data_layout.GetBlockPtr<partition::CellStorageView::CellData>(
-                memory_block, storage::DataLayout::MLD_CELLS);
-            auto mld_cell_level_offsets_ptr = data_layout.GetBlockPtr<std::uint64_t>(
-                memory_block, storage::DataLayout::MLD_CELL_LEVEL_OFFSETS);
-
-            auto source_boundary_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_SOURCE_BOUNDARY);
-            auto destination_boundary_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_DESTINATION_BOUNDARY);
-            auto cells_entries_counts = data_layout.GetBlockEntries(storage::DataLayout::MLD_CELLS);
-            auto cell_level_offsets_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS);
-
-            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);
-
-            mld_cell_storage = partition::CellStorageView{std::move(source_boundary),
-                                                          std::move(destination_boundary),
-                                                          std::move(cells),
-                                                          std::move(level_offsets)};
-        }
-    }
-    void InitializeGraphPointer(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto graph_nodes_ptr = data_layout.GetBlockPtr<GraphNode>(
-            memory_block, storage::DataLayout::MLD_GRAPH_NODE_LIST);
-
-        auto graph_edges_ptr = data_layout.GetBlockPtr<GraphEdge>(
-            memory_block, storage::DataLayout::MLD_GRAPH_EDGE_LIST);
-
-        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(
-            graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_LIST]);
-        util::vector_view<GraphEdge> edge_list(
-            graph_edges_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_EDGE_LIST]);
-        util::vector_view<QueryGraph::EdgeOffset> node_to_offset(
-            graph_node_to_offset_ptr,
-            data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET]);
-
-        query_graph =
-            QueryGraph(std::move(node_list), std::move(edge_list), std::move(node_to_offset));
+        mld_partition = make_partition_view(index, "/mld/multilevelpartition");
+        mld_cell_metric =
+            make_filtered_cell_metric_view(index, "/mld/metrics/" + metric_name, exclude_index);
+        mld_cell_storage = make_cell_storage_view(index, "/mld/cellstorage");
+        query_graph = make_multi_level_graph_view(index, "/mld/multilevelgraph");
     }
 
     // allocator that keeps the allocation data
@@ -1044,24 +653,28 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
 
   public:
     ContiguousInternalMemoryAlgorithmDataFacade(
-        std::shared_ptr<ContiguousBlockAllocator> allocator_, const std::size_t exclude_index)
+        std::shared_ptr<ContiguousBlockAllocator> allocator_,
+        const std::string &metric_name,
+        const std::size_t exclude_index)
         : allocator(std::move(allocator_))
     {
-        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), exclude_index);
+        InitializeInternalPointers(allocator->GetIndex(), metric_name, exclude_index);
     }
 
-    const partition::MultiLevelPartitionView &GetMultiLevelPartition() const override
+    const partitioner::MultiLevelPartitionView &GetMultiLevelPartition() const override
     {
         return mld_partition;
     }
 
-    const partition::CellStorageView &GetCellStorage() const override { return mld_cell_storage; }
+    const partitioner::CellStorageView &GetCellStorage() const override { return mld_cell_storage; }
 
     const customizer::CellMetricView &GetCellMetric() const override { return mld_cell_metric; }
 
     // search graph access
     unsigned GetNumberOfNodes() const override final { return query_graph.GetNumberOfNodes(); }
 
+    unsigned GetMaxBorderNodeID() const override final { return query_graph.GetMaxBorderNodeID(); }
+
     unsigned GetNumberOfEdges() const override final { return query_graph.GetNumberOfEdges(); }
 
     unsigned GetOutDegree(const NodeID n) const override final
@@ -1069,6 +682,31 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
         return query_graph.GetOutDegree(n);
     }
 
+    EdgeRange GetAdjacentEdgeRange(const NodeID node) const override final
+    {
+        return query_graph.GetAdjacentEdgeRange(node);
+    }
+
+    EdgeWeight GetNodeWeight(const NodeID node) const override final
+    {
+        return query_graph.GetNodeWeight(node);
+    }
+
+    EdgeDuration GetNodeDuration(const NodeID node) const override final
+    {
+        return query_graph.GetNodeDuration(node);
+    }
+
+    bool IsForwardEdge(const NodeID node) const override final
+    {
+        return query_graph.IsForwardEdge(node);
+    }
+
+    bool IsBackwardEdge(const NodeID node) const override final
+    {
+        return query_graph.IsBackwardEdge(node);
+    }
+
     NodeID GetTarget(const EdgeID e) const override final { return query_graph.GetTarget(e); }
 
     const EdgeData &GetEdgeData(const EdgeID e) const override final
@@ -1076,11 +714,6 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
         return query_graph.GetEdgeData(e);
     }
 
-    EdgeRange GetAdjacentEdgeRange(const NodeID node) const override final
-    {
-        return query_graph.GetAdjacentEdgeRange(node);
-    }
-
     EdgeRange GetBorderEdgeRange(const LevelID level, const NodeID node) const override final
     {
         return query_graph.GetBorderEdgeRange(level, node);
@@ -1101,10 +734,10 @@ class ContiguousInternalMemoryDataFacade<MLD> final
   private:
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator,
+                                       const std::string &metric_name,
                                        const std::size_t exclude_index)
-        : ContiguousInternalMemoryDataFacadeBase(allocator, exclude_index),
-          ContiguousInternalMemoryAlgorithmDataFacade<MLD>(allocator, exclude_index)
-
+        : ContiguousInternalMemoryDataFacadeBase(allocator, metric_name, exclude_index),
+          ContiguousInternalMemoryAlgorithmDataFacade<MLD>(allocator, metric_name, exclude_index)
     {
     }
 };

include/engine/datafacade/datafacade_base.hpp

@@ -10,24 +10,29 @@
 
 #include "extractor/class_data.hpp"
 #include "extractor/edge_based_node_segment.hpp"
-#include "extractor/guidance/turn_instruction.hpp"
-#include "extractor/guidance/turn_lane_types.hpp"
-#include "extractor/original_edge_data.hpp"
+#include "extractor/maneuver_override.hpp"
 #include "extractor/query_node.hpp"
+#include "extractor/segment_data_container.hpp"
 #include "extractor/travel_mode.hpp"
+#include "extractor/turn_lane_types.hpp"
+
+#include "guidance/turn_bearing.hpp"
+#include "guidance/turn_instruction.hpp"
 
 #include "util/exception.hpp"
 #include "util/guidance/bearing_class.hpp"
 #include "util/guidance/entry_class.hpp"
-#include "util/guidance/turn_bearing.hpp"
 #include "util/guidance/turn_lanes.hpp"
 #include "util/integer_range.hpp"
+#include "util/packed_vector.hpp"
 #include "util/string_util.hpp"
 #include "util/string_view.hpp"
 #include "util/typedefs.hpp"
 
 #include "osrm/coordinate.hpp"
 
+#include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/any_range.hpp>
 #include <cstddef>
 
 #include <string>
@@ -47,10 +52,27 @@ class BaseDataFacade
 {
   public:
     using RTreeLeaf = extractor::EdgeBasedNodeSegment;
+
+    using NodeForwardRange =
+        boost::iterator_range<extractor::SegmentDataView::SegmentNodeVector::const_iterator>;
+    using NodeReverseRange = boost::reversed_range<const NodeForwardRange>;
+
+    using WeightForwardRange =
+        boost::iterator_range<extractor::SegmentDataView::SegmentWeightVector::const_iterator>;
+    using WeightReverseRange = boost::reversed_range<const WeightForwardRange>;
+
+    using DurationForwardRange =
+        boost::iterator_range<extractor::SegmentDataView::SegmentDurationVector::const_iterator>;
+    using DurationReverseRange = boost::reversed_range<const DurationForwardRange>;
+
+    using DatasourceForwardRange =
+        boost::iterator_range<extractor::SegmentDataView::SegmentDatasourceVector::const_iterator>;
+    using DatasourceReverseRange = boost::reversed_range<const DatasourceForwardRange>;
+
     BaseDataFacade() {}
     virtual ~BaseDataFacade() {}
 
-    virtual unsigned GetCheckSum() const = 0;
+    virtual std::uint32_t GetCheckSum() const = 0;
 
     // node and edge information access
     virtual util::Coordinate GetCoordinateOfNode(const NodeID id) const = 0;
@@ -61,34 +83,32 @@ class BaseDataFacade
 
     virtual ComponentID GetComponentID(const NodeID id) const = 0;
 
-    virtual std::vector<NodeID> GetUncompressedForwardGeometry(const EdgeID id) const = 0;
+    virtual NodeForwardRange GetUncompressedForwardGeometry(const EdgeID id) const = 0;
+    virtual NodeReverseRange GetUncompressedReverseGeometry(const EdgeID id) const = 0;
 
-    virtual std::vector<NodeID> GetUncompressedReverseGeometry(const EdgeID id) const = 0;
+    virtual TurnPenalty GetWeightPenaltyForEdgeID(const EdgeID id) const = 0;
 
-    virtual TurnPenalty GetWeightPenaltyForEdgeID(const unsigned id) const = 0;
-
-    virtual TurnPenalty GetDurationPenaltyForEdgeID(const unsigned id) const = 0;
+    virtual TurnPenalty GetDurationPenaltyForEdgeID(const EdgeID id) const = 0;
 
     // Gets the weight values for each segment in an uncompressed geometry.
     // Should always be 1 shorter than GetUncompressedGeometry
-    virtual std::vector<EdgeWeight> GetUncompressedForwardWeights(const EdgeID id) const = 0;
-    virtual std::vector<EdgeWeight> GetUncompressedReverseWeights(const EdgeID id) const = 0;
+    virtual WeightForwardRange GetUncompressedForwardWeights(const EdgeID id) const = 0;
+    virtual WeightReverseRange GetUncompressedReverseWeights(const EdgeID id) const = 0;
 
     // Gets the duration values for each segment in an uncompressed geometry.
     // Should always be 1 shorter than GetUncompressedGeometry
-    virtual std::vector<EdgeWeight> GetUncompressedForwardDurations(const EdgeID id) const = 0;
-    virtual std::vector<EdgeWeight> GetUncompressedReverseDurations(const EdgeID id) const = 0;
+    virtual DurationForwardRange GetUncompressedForwardDurations(const EdgeID id) const = 0;
+    virtual DurationReverseRange GetUncompressedReverseDurations(const EdgeID id) const = 0;
 
     // Returns the data source ids that were used to supply the edge
     // weights.  Will return an empty array when only the base profile is used.
-    virtual std::vector<DatasourceID> GetUncompressedForwardDatasources(const EdgeID id) const = 0;
-    virtual std::vector<DatasourceID> GetUncompressedReverseDatasources(const EdgeID id) const = 0;
+    virtual DatasourceForwardRange GetUncompressedForwardDatasources(const EdgeID id) const = 0;
+    virtual DatasourceReverseRange GetUncompressedReverseDatasources(const EdgeID id) const = 0;
 
     // Gets the name of a datasource
     virtual StringView GetDatasourceName(const DatasourceID id) const = 0;
 
-    virtual extractor::guidance::TurnInstruction
-    GetTurnInstructionForEdgeID(const EdgeID id) const = 0;
+    virtual osrm::guidance::TurnInstruction GetTurnInstructionForEdgeID(const EdgeID id) const = 0;
 
     virtual extractor::TravelMode GetTravelMode(const NodeID id) const = 0;
 
@@ -156,7 +176,7 @@ class BaseDataFacade
 
     virtual bool HasLaneData(const EdgeID id) const = 0;
     virtual util::guidance::LaneTupleIdPair GetLaneData(const EdgeID id) const = 0;
-    virtual extractor::guidance::TurnLaneDescription
+    virtual extractor::TurnLaneDescription
     GetTurnDescription(const LaneDescriptionID lane_description_id) const = 0;
 
     virtual NameID GetNameIndex(const NodeID id) const = 0;
@@ -171,8 +191,6 @@ class BaseDataFacade
 
     virtual StringView GetExitsForID(const NameID id) const = 0;
 
-    virtual std::string GetTimestamp() const = 0;
-
     virtual bool GetContinueStraightDefault() const = 0;
 
     virtual double GetMapMatchingMaxSpeed() const = 0;
@@ -183,8 +201,8 @@ class BaseDataFacade
 
     virtual double GetWeightMultiplier() const = 0;
 
-    virtual util::guidance::TurnBearing PreTurnBearing(const EdgeID eid) const = 0;
-    virtual util::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const = 0;
+    virtual osrm::guidance::TurnBearing PreTurnBearing(const EdgeID eid) const = 0;
+    virtual osrm::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const = 0;
 
     virtual util::guidance::BearingClass GetBearingClass(const NodeID node) const = 0;
 
@@ -193,6 +211,9 @@ class BaseDataFacade
     virtual bool IsLeftHandDriving(const NodeID id) const = 0;
 
     virtual bool IsSegregated(const NodeID) const = 0;
+
+    virtual std::vector<extractor::ManeuverOverride>
+    GetOverridesThatStartAt(const NodeID edge_based_node_id) const = 0;
 };
 }
 }

include/engine/datafacade/mmap_memory_allocator.hpp

@@ -0,0 +1,44 @@
+#ifndef OSRM_ENGINE_DATAFACADE_MMAP_MEMORY_ALLOCATOR_HPP_
+#define OSRM_ENGINE_DATAFACADE_MMAP_MEMORY_ALLOCATOR_HPP_
+
+#include "engine/datafacade/contiguous_block_allocator.hpp"
+
+#include "storage/storage_config.hpp"
+
+#include "util/vector_view.hpp"
+
+#include <boost/iostreams/device/mapped_file.hpp>
+
+#include <memory>
+
+namespace osrm
+{
+namespace engine
+{
+namespace datafacade
+{
+
+/**
+ * This allocator uses file backed mmap memory block as the data location.
+ */
+class MMapMemoryAllocator : public ContiguousBlockAllocator
+{
+  public:
+    explicit MMapMemoryAllocator(const storage::StorageConfig &config,
+                                 const boost::filesystem::path &memory_file);
+    ~MMapMemoryAllocator() override final;
+
+    // interface to give access to the datafacades
+    const storage::SharedDataIndex &GetIndex() override final;
+
+  private:
+    storage::SharedDataIndex index;
+    util::vector_view<char> mapped_memory;
+    boost::iostreams::mapped_file mapped_memory_file;
+};
+
+} // namespace datafacade
+} // namespace engine
+} // namespace osrm
+
+#endif // OSRM_ENGINE_DATAFACADE_SHARED_MEMORY_ALLOCATOR_HPP_