Bumbed version to latest.2

Fix broken assertion after rebase
Make distance_between_roads symmetrical
2017-12-18 15:54:19 +00:00 · 2017-12-18 15:45:04 +00:00 · 2017-12-18 15:24:14 +00:00 · 2017-12-18 15:24:14 +00:00 · 2017-12-18 15:24:14 +00:00 · 2017-12-18 15:24:14 +00:00
301 changed files with 4430 additions and 13618 deletions
@@ -2,18 +2,13 @@

 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 tests (see [testing documentation](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/testing.md)
+ - [ ] add regression / cucumber cases (see 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?
@@ -13,7 +13,6 @@ notifications:
 branches:
  only:
    - master
-    - "5.16"
    # enable building tags
    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/

@@ -65,12 +64,12 @@ matrix:
      after_success:

    - os: linux
-      compiler: "gcc-7-debug-cov"
-      addons: &gcc7
+      compiler: "gcc-6-debug-cov"
+      addons: &gcc6
        apt:
          sources: ['ubuntu-toolchain-r-test']
-          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
+          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
      before_script:
        - cd ${TRAVIS_BUILD_DIR}
        - lcov --directory . --zerocounters # clean cached da files
@@ -84,20 +83,20 @@ matrix:
        - bash <(curl -s https://codecov.io/bash) || echo "Codecov did not collect coverage reports"

    - os: linux
-      compiler: "gcc-7-debug-asan"
-      addons: &gcc7
+      compiler: "gcc-6-debug-asan"
+      addons: &gcc6
        apt:
          sources: ['ubuntu-toolchain-r-test']
-          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"
+          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"

    - os: linux
-      compiler: "clang-5.0-debug"
-      addons: &clang50
+      compiler: "clang-4.0-debug"
+      addons: &clang40
        apt:
          sources: ['ubuntu-toolchain-r-test']
-          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
+          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

    - os: linux
      compiler: "mason-linux-debug-asan"
@@ -105,7 +104,7 @@ matrix:
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['libstdc++-4.9-dev']
-      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"
+      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"

    # Release Builds
    - os: linux
@@ -114,70 +113,80 @@ matrix:
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON RUN_CLANG_FORMAT=ON ENABLE_LTO=ON
-
-    - os: linux
-      compiler: "gcc-7-release"
-      addons: &gcc7
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          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-7-release-i686"
-      env: >
-        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-7-stxxl"
-      addons: &gcc7
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          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-5-release"
-      addons: &gcc49
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          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'
+      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON RUN_CLANG_FORMAT=ON ENABLE_LTO=ON

    - os: linux
      compiler: "gcc-6-release"
+      addons: &gcc6
+        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'
+
+    - os: linux
+      compiler: "gcc-6-release-i686"
+      env: >
+        TARGET_ARCH='i686' CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release'
+        CFLAGS='-m32 -msse2 -mfpmath=sse' CXXFLAGS='-m32 -msse2 -mfpmath=sse'
+
+    - os: linux
+      compiler: "gcc-6-stxxl"
+      addons: &gcc6
+        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
+
+    - os: linux
+      compiler: "gcc-4.9-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'
+          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'

    - os: osx
-      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"
+      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="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-7-release-shared"
-      addons: &gcc7
+      compiler: "gcc-6-release-shared"
+      addons: &gcc6
        apt:
          sources: ['ubuntu-toolchain-r-test']
-          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
+          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

    # Node build jobs. These skip running the tests.
    - os: linux
@@ -187,7 +196,7 @@ matrix:
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="4"
+      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3
      install:
        - pushd ${OSRM_BUILD_DIR}
        - |
@@ -206,12 +215,60 @@ matrix:

    - os: linux
      sudo: false
-      compiler: "node-4-mason-linux-debug"
+      compiler: "node-4-mason-linux-release"
      addons:
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="4"
+      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"
      install:
        - pushd ${OSRM_BUILD_DIR}
        - |
@@ -235,7 +292,7 @@ matrix:
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="8"
+      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="8"
      install:
        - pushd ${OSRM_BUILD_DIR}
        - |
@@ -254,12 +311,12 @@ matrix:

    - os: linux
      sudo: false
-      compiler: "node-8-mason-linux-debug"
+      compiler: "node-6-mason-linux-release"
      addons:
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="8"
+      env: CLANG_VERSION='4.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="8"
      install:
        - pushd ${OSRM_BUILD_DIR}
        - |
@@ -374,7 +431,7 @@ script:
  - ./unit_tests/engine-tests
  - ./unit_tests/util-tests
  - ./unit_tests/server-tests
-  - ./unit_tests/partitioner-tests
+  - ./unit_tests/partition-tests
  - |
    if [ -z "${ENABLE_SANITIZER}" ] && [ "$TARGET_ARCH" != "i686" ]; then
      npm run nodejs-tests
@@ -1,74 +1,10 @@
-# 5.16.1
-  - Changes from 5.16.0:
-    - Bugfixes
-      - FIXED #4909: deduplication of route steps when waypoints are used [#4909](https://github.com/Project-OSRM/osrm-backend/issues/4909)
-
-# 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:
+# UNRELEASED
+ - Changes from 5.14.1:
+   - Bugfixes:
+      - FIXED #4727: Erroring when a old .core file is present.
      - 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:
-    - Features:
-      - Added a `waypoints` parameter to the match service plugin that accepts indices to input coordinates and treats only those points as waypoints in the response format.
-    - Bugfixes:
-      - FIXED #4754: U-Turn penalties are applied to straight turns.
-      - FIXED #4756: Removed too restrictive road name check in the sliproad handler
-      - FIXED #4731: Use correct weights for edge-based graph duplicated via nodes.
-    - Profile:
-      - CHANGED: added Belarus speed limits
-      - CHANGED: set default urban speed in Ukraine to 50kmh
-
-# 5.14.2
-  - Changes from 5.14.1:
-    - Bugfixes:
-      - FIXED #4727: Erroring when a old .core file is present.
-      - FIXED #4642: Update checks for EMPTY_NAMEID to check for empty name strings
-      - FIXED #4738: Fix potential segmentation fault
-    - Node.js Bindings:
-      - ADDED: Exposed new `max_radiuses_map_matching` option from `EngingConfig` options
-    - Tools:
-      - ADDED: New osrm-routed `max_radiuses_map_matching` command line flag to optionally set a maximum radius for map matching

 # 5.14.1
  - Changes from 5.14.0
@@ -43,6 +43,7 @@ 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,8 +61,8 @@ if (POLICY CMP0048)
 endif()
 project(OSRM C CXX)
 set(OSRM_VERSION_MAJOR 5)
-set(OSRM_VERSION_MINOR 16)
-set(OSRM_VERSION_PATCH 1)
+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}")
@@ -101,10 +102,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>=5.0 and Clang>=3.4 - GCC 4.8 is already too old for C++14.
+# Strictly require GCC>=4.9 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 5.0)
-    message(FATAL_ERROR "GCC>=5.0 required. In case you are on Ubuntu upgrade via ppa:ubuntu-toolchain-r/test")
+  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")
  endif()
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
@@ -125,8 +126,7 @@ configure_file(
 )
 file(GLOB UtilGlob src/util/*.cpp src/util/*/*.cpp)
 file(GLOB ExtractorGlob src/extractor/*.cpp src/extractor/*/*.cpp)
-file(GLOB GuidanceGlob src/guidance/*.cpp src/extractor/intersection/*.cpp)
-file(GLOB PartitionerGlob src/partitioner/*.cpp)
+file(GLOB PartitionerGlob src/partition/*.cpp)
 file(GLOB CustomizerGlob src/customize/*.cpp)
 file(GLOB ContractorGlob src/contractor/*.cpp)
 file(GLOB UpdaterGlob src/updater/*.cpp)
@@ -137,7 +137,6 @@ 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})
@@ -157,9 +156,8 @@ 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_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_guidance $<TARGET_OBJECTS:GUIDANCE> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm_partition src/osrm/partitioner.cpp $<TARGET_OBJECTS:PARTITIONER> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm_customize src/osrm/customizer.cpp $<TARGET_OBJECTS:CUSTOMIZER> $<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>)

@@ -258,7 +256,8 @@ 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 MINGW)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND
+        NOT "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9.0" 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")
@@ -286,6 +285,12 @@ 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()

@@ -312,9 +317,8 @@ 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} ${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")
+  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")
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
  set(COLOR_FLAG "-fdiagnostics-color=auto")
  check_cxx_compiler_flag("-fdiagnostics-color=auto" HAS_COLOR_FLAG)
@@ -322,8 +326,7 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
    set(COLOR_FLAG "")
  endif()
  # using GCC
-  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")
-
+  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")
  if(WIN32) # using mingw
    add_dependency_defines(-DWIN32)
    set(OPTIONAL_SOCKET_LIBS ws2_32 wsock32)
@@ -621,12 +624,6 @@ 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}
@@ -673,14 +670,13 @@ set(UTIL_LIBRARIES
    ${CMAKE_THREAD_LIBS_INIT}
    ${MAYBE_STXXL_LIBRARY}
    ${TBB_LIBRARIES}
-    ${MAYBE_COVERAGE_LIBRARIES}
-    ${ZLIB_LIBRARY})
+    ${MAYBE_COVERAGE_LIBRARIES})

 # 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 osrm_guidance ${EXTRACTOR_LIBRARIES})
+target_link_libraries(osrm_extract ${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})
@@ -696,6 +692,15 @@ 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)
@@ -718,14 +723,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/partitioner/partitioner.hpp include/partitioner/partitioner_config.hpp)
+set(PartitionerHeader include/partition/partitioner.hpp include/partition/partition_config.hpp)
 set(ContractorHeader include/contractor/contractor.hpp include/contractor/contractor_config.hpp)
 set(StorageHeader include/storage/storage.hpp include/storage/io_config.hpp include/storage/storage_config.hpp)
 install(FILES ${EngineHeader} DESTINATION include/osrm/engine)
 install(FILES ${UtilHeader} DESTINATION include/osrm/util)
 install(FILES ${StorageHeader} DESTINATION include/osrm/storage)
 install(FILES ${ExtractorHeader} DESTINATION include/osrm/extractor)
-install(FILES ${PartitionerHeader} DESTINATION include/osrm/partitioner)
+install(FILES ${PartitionerHeader} DESTINATION include/osrm/partition)
 install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
 install(FILES ${LibraryGlob} DESTINATION include/osrm)
 install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
@@ -59,14 +59,9 @@ 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
@@ -119,8 +114,7 @@ sudo cmake --build . --target install

 ### Request Against the Demo Server

-Read the [API usage policy](https://github.com/Project-OSRM/osrm-backend/wiki/Demo-server).
-
+Read the [API usage policy](https://github.com/Project-OSRM/osrm-backend/wiki/Api-usage-policy).
 Simple query with instructions and alternatives on Berlin:

 ```
@@ -161,6 +161,29 @@ 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%
@@ -29,7 +29,24 @@ 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
@@ -0,0 +1,21 @@
+# - 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)
@@ -10,6 +10,43 @@
        "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
@@ -322,6 +359,10 @@
              92.56116628646856,
              15.147674168282906
            ],
+            [
+              88.78186941146853,
+              12.158807474538182
+            ],
            [
              90.71546316146853,
              0.759386240320313
@@ -351,8 +392,8 @@
              -33.73235247373941
            ],
            [
-              159.78515624999997,
-              -21.943045533438166
+              164.3678069114686,
+              -30.759557257019974
            ]
          ]
        ]
@@ -368,8 +409,12 @@
        "coordinates": [
          [
            [
-              147.15087890625003,
-              44.13885576756881
+              147.381591796875,
+              43.26920624914964
+            ],
+            [
+              147.06298828125,
+              44.22158376545796
            ],
            [
              145.52490234375,
@@ -387,13 +432,37 @@
              141.48193359375,
              45.836454050187726
            ],
+            [
+              140.38330078125,
+              45.47554027158593
+            ],
+            [
+              138.021240234375,
+              41.08763212467916
+            ],
            [
              135.0439453125,
              37.71859032558816
            ],
            [
-              127.88085937500001,
-              32.565333160841035
+              132.462158203125,
+              36.37706783983682
+            ],
+            [
+              130.53955078125,
+              34.71452466170392
+            ],
+            [
+              129.00146484375,
+              33.568861182555565
+            ],
+            [
+              127.891845703125,
+              32.54681317351514
+            ],
+            [
+              127.606201171875,
+              30.240086360983426
            ],
            [
              125.61767578124999,
@@ -412,12 +481,28 @@
              25.284437746983055
            ],
            [
-              141.36108398437503,
-              33.394759218577995
+              136.3623046875,
+              30.41078179084589
            ],
            [
-              147.15087890625003,
-              44.13885576756881
+              143.67919921874997,
+              33.925129700072
+            ],
+            [
+              144.25048828125,
+              39.605688178320804
+            ],
+            [
+              147.45849609375,
+              42.48830197960227
+            ],
+            [
+              147.94189453125,
+              43.13306116240612
+            ],
+            [
+              147.381591796875,
+              43.26920624914964
            ]
          ]
        ]
@@ -432,6 +517,18 @@
        "type": "Polygon",
        "coordinates": [
          [
+            [
+              2.63671875,
+              52.119998657638156
+            ],
+            [
+              2.5048828125,
+              53.527247970102465
+            ],
+            [
+              -0.0439453125,
+              56.992882804633986
+            ],
            [
              1.9116210937499998,
              61.19621314083867
@@ -441,12 +538,24 @@
              61.990587736204105
            ],
            [
-              -12.54638671875,
-              55.94919982336746
+              -7.6025390625,
+              59.678835236960765
            ],
            [
-              -12.260742187500002,
-              50.62507306341437
+              -12.28271484375,
+              55.51619215717891
+            ],
+            [
+              -12.19482421875,
+              51.2206474303833
+            ],
+            [
+              -6.591796875,
+              49.403824657885124
+            ],
+            [
+              -3.251953125,
+              49.25346477497736
            ],
            [
              -1.9445800781249998,
@@ -468,13 +577,17 @@
              -0.3515625,
              49.69606181911566
            ],
+            [
+              0.87890625,
+              50.736455137010665
+            ],
            [
              2.5048828125,
              51.6180165487737
            ],
            [
-              1.9116210937499998,
-              61.19621314083867
+              2.63671875,
+              52.119998657638156
            ]
          ]
        ]
@@ -489,6 +602,10 @@
        "type": "Polygon",
        "coordinates": [
          [
+            [
+              91.77978515625,
+              20.899871347076424
+            ],
            [
              92.39501953125,
              21.514406720030294
@@ -833,6 +950,10 @@
              61.58935546875,
              25.224820176765036
            ],
+            [
+              67.8076171875,
+              16.678293098288513
+            ],
            [
              74.970703125,
              7.580327791330129
@@ -846,12 +967,16 @@
              -2.986927393334863
            ],
            [
-              85.86914062500001,
-              5.5941182188847876
+              84.8583984375,
+              0.4833927027896987
            ],
            [
-              92.39501953125,
-              21.514406720030294
+              88.3740234375,
+              14.774882506516272
+            ],
+            [
+              91.77978515625,
+              20.899871347076424
            ]
          ]
        ]
@@ -860,15 +985,23 @@
    {
      "type": "Feature",
      "properties": {
-        "driving_side": "left"
+        "stroke": "#555555",
+        "stroke-width": 2,
+        "stroke-opacity": 1,
+        "fill": "#555555",
+        "fill-opacity": 0.5
      },
      "geometry": {
        "type": "Polygon",
        "coordinates": [
          [
            [
-              43.57177734375001,
-              -4.390228926463384
+              43.41796875,
+              -3.1405161039832357
+            ],
+            [
+              41.6162109375,
+              -1.7355743631421197
            ],
            [
              41.0009765625,
@@ -1131,8 +1264,20 @@
              -34.74161249883172
            ],
            [
-              43.57177734375001,
-              -4.390228926463384
+              40.95703125,
+              -18.646245142670598
+            ],
+            [
+              42.2314453125,
+              -13.581920900545844
+            ],
+            [
+              41.3525390625,
+              -8.754794702435618
+            ],
+            [
+              43.41796875,
+              -3.1405161039832357
            ]
          ]
        ]
@@ -1573,24 +1718,24 @@
        "coordinates": [
          [
            [
-              -81.67236328125001,
-              19.03875247795316
+              -82.012939453125,
+              18.90108960836388
            ],
            [
-              -79.76898193359376,
-              19.48989674307901
+              -80.48583984375,
+              18.90108960836388
            ],
            [
-              -79.48333740234375,
-              19.888140273126222
+              -80.48583984375,
+              19.735683578629445
            ],
            [
-              -81.45263671875001,
-              19.46400263520258
+              -82.012939453125,
+              19.735683578629445
            ],
            [
-              -81.67236328125001,
-              19.03875247795316
+              -82.012939453125,
+              18.90108960836388
            ]
          ]
        ]
@@ -1834,387 +1979,6 @@
          ]
        ]
      }
-    },
-    {
-      "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
-            ]
-          ]
-        ]
-      }
    }
  ]
 }
@@ -288,7 +288,6 @@ In addition to the [general options](#general-options) the following options are
 |radiuses    |`{radius};{radius}[;{radius} ...]`              |Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy.|
 |gaps        |`split` (default), `ignore`                     |Allows the input track splitting based on huge timestamp gaps between points.             |
 |tidy        |`true`, `false` (default)                       |Allows the input track modification to obtain better matching quality for noisy tracks.   |
-|waypoints   | `{index};{index};{index}...`                   |Treats input coordinates indicated by given indices as waypoints in returned Match object. Default is to treat all input coordinates as waypoints.    |

 |Parameter   |Values                             |
 |------------|-----------------------------------|
@@ -515,10 +514,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 weights. |
-| false        | `undefined`                                                                   |
+| annotations  |                                                                       |
+|--------------|-----------------------------------------------------------------------|
+| true         | An `Annotation` object containing node ids, durations distances and   |
+| false        | weights `undefined`                                                   |

 #### Example

@@ -208,103 +208,16 @@ 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 (`[-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 it from a restricted access road? (See definition in `process_way`)
-target_mode                        | Read          | Enum                      | Travel mode before 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
-}
-```
+Attribute          | Read/write? | Type    | Notes
+-------------------|-------------|---------|------------------------------------------------------
+direction_modifier | Read        | Enum    | Geometry of turn. Defined in `include/extractor/guidance/turn_instruction.hpp`
+turn_type          | Read        | Enum    | Priority of turn. Defined in `include/extractor/guidance/turn_instruction.hpp`
+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`)
+angle              | Read        | Float   | Angle of turn in degrees (`0-360`: `0`=u-turn, `180`=straight on)
+duration           | Read/write  | Float   | Penalty to be applied for this turn (duration in deciseconds)
+weight             | Read/write  | Float   | Penalty to be applied for this turn (routing weight)

 ## Guidance
 The guidance parameters in profiles are currently a work in progress. They can and will change.
@@ -45,11 +45,3 @@ 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     |
@@ -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 tag toll with a class
+    Scenario: Car - We toll restricted with a class
        Given the node map
            """
            a b
@@ -99,45 +99,6 @@ 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
            """
@@ -163,3 +124,4 @@ 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)],[()] |
+
@@ -131,57 +131,3 @@ 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    |
-
-    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
@@ -1,50 +0,0 @@
-@routing @car
-Feature: Car - Handle physical limitation
-
-    Background:
-        Given the profile "car"
-
-    Scenario: Car - Use a narrow way
-        Then routability should be
-            | highway | width  | narrow | bothw |
-            | primary |        |        | x     |
-            | primary | narrow |        | x     |
-            | primary |        | yes    | x     |
-            | primary | 1.8    |        |       |
-            | primary | 1.9    |        |       |
-            | primary | 2.0    |        | x     |
-            | primary | 2.1    |        | x     |
-            | primary | 1m     |        |       |
-            | primary | 1 m    |        |       |
-            | primary | 3 m    |        | x     |
-            | primary | 6'     |        |       |
-            | primary | 6'0"   |        |       |
-            | primary | 6'2"   |        |       |
-            | primary | 6'3"   |        | x     |
-            | primary | 7'     |        | x     |
-            | primary | 7'0"   |        | x     |
-
-    Scenario: Car - Limited by width
-        Then routability should be
-            | highway | maxwidth:physical | maxwidth | width | est_width | bothw |
-            | primary | 1                 |          |       |           |       |
-            | primary | 3                 |          |       |           | x     |
-            | primary |                   | 1        |       |           |       |
-            | primary |                   | 3        |       |           | x     |
-            | primary |                   |          | 1     |           |       |
-            | primary |                   |          | 3     |           | x     |
-            | primary |                   |          |       | 1         |       |
-            | primary |                   |          |       | 3         | x     |
-
-    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     |
@@ -141,33 +141,6 @@ 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
@@ -1061,28 +1034,3 @@ 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 |
@@ -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
@@ -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,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        |
+            | 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 |

    Scenario: Tunnel with Immediate Turn Front and Back
        Given the node map
@@ -129,3 +129,4 @@ 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  |
+
@@ -992,6 +992,7 @@ Feature: Slipways and Dedicated Turn Lanes
            | dbef  | primary      | dbef  |        |
            | ae    | primary_link | ae    | yes    |

+
       When I route I should get
            | waypoints | route          | turns                    | locations |
            | s,f       | sabc,dbef,dbef | depart,turn right,arrive | s,a,f     |
@@ -1018,6 +1019,7 @@ Feature: Slipways and Dedicated Turn Lanes
            | dbcf  | primary      | dbcf |        |
            | ac    | primary_link | ae   | yes    |

+
       When I route I should get
            | waypoints | route         | turns                    | locations |
            | s,f       | sab,dbcf,dbcf | depart,turn right,arrive | s,a,f     |
@@ -1045,55 +1047,7 @@ Feature: Slipways and Dedicated Turn Lanes
            | ae    | primary_link | sab   | yes    |
            | cg    | primary      | cg    |        |

+
       When I route I should get
            | waypoints | route           | turns                    | locations |
            | s,f       | sab,dbcef,dbcef | depart,turn right,arrive | s,a,f     |
-
-
-    @sliproads
-    Scenario: Sliproad converted from a fork
-        Given the node map
-            """
-                     d
-                     .
-                     b
-              s . a '.
-                    `c
-                     .
-                     f
-            """
-
-        And the ways
-            | nodes | highway  | name | ref   | oneway |
-            | sa    | tertiary |      | D 60A | yes    |
-            | ab    | tertiary | ab   | D 60A | yes    |
-            | ac    | tertiary |      | D 60A | yes    |
-            | dbcf  | tertiary | dbcf | D 543 | yes    |
-
-       When I route I should get
-            | waypoints | route      | turns                    | locations |
-            | s,f       | ,dbcf,dbcf | depart,turn right,arrive | s,a,f     |
-
-
-    @sliproads
-    Scenario: Sliproad to a road with a reference only
-        Given the node map
-            """
-            s . a . b . d
-                 `  .
-                  ' .
-                   ..
-                    c
-                    .
-                    f
-            """
-
-        And the ways
-            | nodes | highway      | name | ref  | oneway |
-            | sabd  | primary      | road |      |        |
-            | bcf   | primary      |      | K108 |        |
-            | ac    | primary_link |      |      | yes    |
-
-       When I route I should get
-            | waypoints | route  | turns                    | locations |
-            | s,f       | road,, | depart,turn right,arrive | s,a,f     |
@@ -1,223 +0,0 @@
-# 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 |
-
-        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           |
-
-    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 |
@@ -393,7 +393,7 @@ Feature: Merge Segregated Roads
            """
              a
              |
-              b-----z
+              b
             / \
            c   h
            |   |
@@ -402,9 +402,6 @@ Feature: Merge Segregated Roads
            |   |
            |   |
            |   |
-            |   |
-            |   |
-            |   |
            d   g
             \ /
              e
@@ -413,24 +410,18 @@ Feature: Merge Segregated Roads
            """

        And the ways
-            | nodes | name  | oneway |
-            | ab    | road  | no     |
-            | ef    | road  | no     |
-            | bcde  | road  | yes    |
-            | eghb  | road  | yes    |
-            | bz    | cross | no  |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction  |
-            | restriction | bz       | bcde   | b        | no_left_turn |
+            | nodes | name | oneway |
+            | ab    | road | no     |
+            | ef    | road | no     |
+            | bcde  | road | yes    |
+            | eghb  | road | yes    |

        When I route I should get
-            | waypoints | turns                    | route           |
-            | a,f       | depart,arrive            | road,road       |
-            | c,f       | depart,arrive            | road,road       |
-            | f,a       | depart,arrive            | road,road       |
-            | g,a       | depart,arrive            | road,road       |
-            | z,a       | depart,turn right,arrive | cross,road,road |
+            | waypoints | turns         | route     |
+            | a,f       | depart,arrive | road,road |
+            | c,f       | depart,arrive | road,road |
+            | f,a       | depart,arrive | road,road |
+            | g,a       | depart,arrive | road,road |

    Scenario: Traffic Island
        Given the node map
@@ -601,10 +592,10 @@ Feature: Merge Segregated Roads

        When I route I should get
            | waypoints | route          | turns                        |
-            | a,c       | germ,ober      | depart,arrive                |
-            | a,g       | germ,germ,germ | depart,continue right,arrive |
-            | a,1       | germ,germ,germ | depart,continue left,arrive  |
-            | d,g       | ober,germ,germ | depart,turn left,arrive      |
+			| a,c       | germ,ober      | depart,arrive                |
+			| a,g       | germ,germ,germ | depart,continue right,arrive |
+			| a,1       | germ,germ,germ | depart,continue left,arrive  |
+			| d,g       | ober,germ,germ | depart,turn left,arrive      |

    # https://www.openstreetmap.org/#map=19/51.32888/6.57059
    Scenario: Places in presence of oneways
@@ -636,16 +627,16 @@ Feature: Merge Segregated Roads
            | cf    | albrecht | yes    |

        When I route I should get
-            | waypoints | route                              | turns                                          |
-            | a,l       | schwert,albrecht,marianne,marianne | depart,new name straight,turn left,arrive      |
-            | a,j       | schwert,luise,luise                | depart,turn right,arrive                       |
-            | a,1       | schwert,albrecht,albrecht,albrecht | depart,new name straight,continue uturn,arrive |
-            | k,l       | marianne,marianne                  | depart,arrive                                  |
-            | 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,l       | luise,albrecht,marianne,marianne   | depart,turn left,turn left,arrive              |
+            | waypoints | route                                       | turns                                                        |
+            | a,l       | schwert,albrecht,marianne,marianne          | depart,new name straight,turn left,arrive                    |
+            | a,j       | schwert,luise,luise                         | depart,turn right,arrive                                     |
+			| a,1       | schwert,albrecht,albrecht,albrecht          | depart,new name straight,continue uturn,arrive               |
+			| k,l       | marianne,marianne                           | depart,arrive                                                |
+            | 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,l       | luise,albrecht,marianne,marianne            | depart,turn left,turn left,arrive                            |

    # https://www.openstreetmap.org/#map=19/52.46339/13.40272
    Scenario: Do not merge links between segregated roads
@@ -81,7 +81,7 @@ Feature: Motorway Guidance
            """
                 ,g,e
               ,f,d
-            a-b-c
+            a-b-c 
            """

        And the ways
@@ -281,67 +281,3 @@ 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 |
@@ -382,21 +382,6 @@ 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
            """
@@ -745,15 +745,12 @@ Feature: Basic Roundabout


     Scenario: Drive through roundabout
-        Given a grid size of 5 meters
        Given the node map
           """
-                . a .
-              .       .
-            b     e --- d ---- f
-              .        .
-                 .c.
-               g     h
+              a
+            b e d  f
+              c
+            g   h
           """

        And the ways
@@ -763,12 +760,12 @@ Feature: Basic Roundabout
           | gch   |            | yes    |

        When I route I should get
-           | waypoints | bearings | route           | turns                                                        |
-           | e,f       | 90 90    | edf,edf         | depart,arrive                                                |
-           | e,h       | 90 130   | edf,gch,gch,gch | depart,roundabout-exit-2,exit roundabout straight,arrive     |
-           | g,f       | 50 90    | gch,edf,edf,edf | depart,roundabout-exit-2,exit roundabout slight right,arrive |
-           | g,h       | 50 130   | gch,gch,gch     | depart,exit roundabout right,arrive                          |
-           | e,e       | 90 270   | edf,edf,edf,edf | depart,roundabout-exit-3,exit roundabout sharp left,arrive   |
+           | waypoints | bearings | route           | turns                                                      |
+           | e,f       | 90 90    | edf,edf         | depart,arrive                                              |
+           | e,h       | 90 135   | edf,gch,gch,gch | depart,roundabout-exit-2,exit roundabout straight,arrive   |
+           | g,f       | 45 90    | gch,edf,edf,edf | depart,roundabout-exit-2,exit roundabout right,arrive      |
+           | g,h       | 45 135   | gch,gch,gch     | depart,exit roundabout right,arrive                        |
+           | e,e       | 90 270   | edf,edf,edf     | depart,continue uturn,arrive                               |

    Scenario: CCW and CW roundabouts with overlaps
        Given the node map
@@ -129,12 +129,8 @@ 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 ('way ' .. tostring(way:get_location_tag('answer')))
+           print ('answer ' .. tostring(way:get_location_tag('answer')))
           result.forward_mode = mode.driving
           result.forward_speed = 1
        end
@@ -152,5 +148,4 @@ 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 "node 42"
-        And stdout should contain "way 42"
+        And stdout should contain "answer 42"
@@ -1,186 +0,0 @@
-@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 11"
-        # 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/
-
-
-
-
@@ -185,34 +185,31 @@ module.exports = function () {

        let q = d3.queue();

-        let addRelation = (headers, row, cb) => {
+        let addRelation = (row, cb) => {
            let relation = new OSM.Relation(this.makeOSMId(), this.OSM_USER, this.OSM_TIMESTAMP, this.OSM_UID);


            var name = null;
-            for (let index in row) {
-
-                var key = headers[index];
-                var value = row[index];
+            for (let key in row) {
                let isNode = key.match(/^node:?(.*)/),
                    isWay = key.match(/^way:?(.*)/),
                    isRelation = key.match(/^relation:?(.*)/),
                    isColonSeparated = key.match(/^(.*):(.*)/);
                if (isNode) {
-                    value.split(',').map(function(v) { return v.trim(); }).forEach((nodeName) => {
+                    row[key].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) {
-                    value.split(',').map(function(v) { return v.trim(); }).forEach((wayName) => {
+                    row[key].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) {
-                    value.split(',').map(function(v) { return v.trim(); }).forEach((relName) => {
+                    row[key].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]);
@@ -220,8 +217,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, value);
-                    if (key.match(/name/)) name = value;
+                    relation.addTag(key, row[key]);
+                    if (key.match(/name/)) name = row[key];
                }
            }
            relation.uid = this.OSM_UID;
@@ -236,8 +233,7 @@ module.exports = function () {
            cb();
        };

-        var headers = table.raw()[0];
-        table.rows().forEach((row) => q.defer(addRelation, headers, row));
+        table.hashes().forEach((row) => q.defer(addRelation, row));

        q.awaitAll(callback);
    });
@@ -150,8 +150,7 @@ module.exports = function () {
                    }
                    var ok = true;
                    var encodedResult = '',
-                        extendedTarget = '',
-                        resultWaypoints = [];
+                        extendedTarget = '';

                    var testSubMatching = (sub, si) => {
                        var testSubNode = (ni) => {
@@ -187,29 +186,6 @@ module.exports = function () {
                        });
                    }

-                    if (headers.has('waypoints')) {
-                        var got_loc = [];
-                        for (let i = 0; i < json.tracepoints.length; i++) {
-                            if (!json.tracepoints[i]) continue;
-                            if (json.tracepoints[i].waypoint_index != null)
-                                got_loc.push(json.tracepoints[i].location);
-                        }
-
-                        if (row.waypoints.length != got_loc.length)
-                            return cb(new Error(`Expected ${row.waypoints.length} waypoints, got ${got_loc.length}`));
-
-                        for (i = 0; i < row.waypoints.length; i++)
-                        {
-                            var want_node = this.findNodeByName(row.waypoints[i]);
-                            if (!this.FuzzyMatch.matchLocation(got_loc[i], want_node)) {
-                                resultWaypoints.push(util.format('? [%s,%s]', got_loc[i][0], got_loc[i][1]));
-                                ok = false;
-                            } else {
-                                resultWaypoints.push(row.waypoints[i]);
-                            }
-                        }
-                    }
-
                    if (ok) {
                        if (headers.has('matchings')) {
                            got.matchings = row.matchings;
@@ -218,12 +194,7 @@ module.exports = function () {
                        if (headers.has('timestamps')) {
                            got.timestamps = row.timestamps;
                        }
-
-                        if (headers.has('waypoints')) {
-                            got.waypoints = row.waypoints;
-                        }
                    } else {
-                        got.waypoints = resultWaypoints.join(';');
                        got.matchings = encodedResult;
                        row.matchings = extendedTarget;
                    }
@@ -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,7 +115,6 @@ 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
        ];

@@ -44,7 +44,7 @@ module.exports = function () {

        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_PROFILE = process.env.OSRM_PROFILE;

        if (this.PLATFORM_WINDOWS) {
@@ -72,7 +72,6 @@ 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');

@@ -50,8 +50,6 @@ 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) => {
@@ -59,27 +59,3 @@ 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: 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:10  | 249.998641:299.931643:0 | 25:30:0    | 1:2:3   |
@@ -1,68 +0,0 @@
-@routing @testbot @exclude
-Feature: Testbot - Exclude flags regression tests
-    Background:
-        Given the profile "testbot"
-
-    Scenario: Testbot - Exclude toll regression 1
-        Given the node map
-            """
-            a               g
-            .               .
-            b....d-$-$-e....f
-            .               .
-            c               h
-            """
-
-        And the ways
-            | nodes | highway  | toll | #               |
-            | ab    | primary  |      | always drivable |
-            | cb    | primary  |      | always drivable |
-            | bd    | primary  |      | always drivable |
-            | de    | motorway | yes  | not drivable for exclude=toll |
-            | ef    | primary  |      | always drivable |
-            | fg    | primary  |      | always drivable |
-            | fh    | primary  |      | always drivable |
-
-        Given the query options
-            | exclude | toll |
-
-        When I route I should get
-            | from | to | route         |
-            | a    | h  |               |
-            | a    | g  |               |
-            | g    | a  |               |
-            | d    | e  |               |
-
-    Scenario: Testbot - Exclude toll regression 2
-        Given the profile "testbot"
-
-        Given the node map
-            """
-            a               g
-            .               .
-            b....d-$-$-e....f
-            .               .
-            c               h..i
-            """
-
-        And the ways
-            | nodes | highway  | toll | #               |
-            | ab    | primary  |      | always drivable |
-            | cb    | primary  |      | always drivable |
-            | bd    | primary  |      | always drivable |
-            | de    | motorway | yes  | not drivable for exclude=toll |
-            | ef    | primary  |      | always drivable |
-            | fg    | primary  |      | always drivable |
-            | fh    | primary  |      | always drivable |
-            | hi    | primary  |      | always drivable |
-
-        Given the query options
-            | exclude | toll |
-
-        When I route I should get
-            | from | to | route         |
-            | a    | h  |               |
-            | a    | g  |               |
-            | g    | a  |               |
-            | d    | e  |               |
-            | d    | i  |               |
@@ -480,207 +480,3 @@ Feature: Basic Map Matching
            | trace | a:nodes     |
            | 12    | 1:2:3:4:5:6 |
            | 21    | 6:5:4:3:2:1 |
-
-
-    Scenario: Matching with waypoints param for start/end
-        Given the node map
-            """
-            a-----b---c
-                  |
-                  |
-                  d
-                  |
-                  |
-                  e
-            """
-        And the ways
-            | nodes | oneway |
-            | abc   | no     |
-            | bde   | no     |
-
-        Given the query options
-            | waypoints | 0;3   |
-
-        When I match I should get
-            | trace | code    | matchings | waypoints |
-            | abde  | Ok      | abde      | ae        |
-
-    Scenario: Matching with waypoints param that were tidied away
-        Given the node map
-            """
-            a - b - c - e
-                    |
-                    f
-                    |
-                    g
-            """
-        And the ways
-            | nodes | oneway |
-            | abce  | no     |
-            | cfg   | no     |
-
-        Given the query options
-            | tidy      | true    |
-            | waypoints | 0;2;5   |
-
-        When I match I should get
-            | trace  | code    | matchings | waypoints |
-            | abccfg | Ok      | abcfg     | acg       |
-
-    Scenario: Testbot - Map matching refuses to use waypoints with trace splitting
-        Given the node map
-            """
-            a b c d
-                e
-            """
-        Given the query options
-            | waypoints | 0;3   |
-
-        And the ways
-            | nodes | oneway |
-            | abcd  | no     |
-
-        When I match I should get
-            | trace | timestamps | code     |
-            | abcd  | 0 1 62 63  | NoMatch  |
-
-    Scenario: Testbot - Map matching invalid waypoints
-        Given the node map
-            """
-            a b c d
-                e
-            """
-        Given the query options
-            | waypoints | 0;4   |
-
-        And the ways
-            | nodes | oneway |
-            | abcd  | no     |
-
-        When I match I should get
-            | trace | code           |
-            | abcd  | InvalidOptions |
-
-    Scenario: Matching fail with waypoints param missing start/end
-        Given the node map
-            """
-            a-----b---c
-                  |
-                  |
-                  d
-                  |
-                  |
-                  e
-            """
-        And the ways
-            | nodes | oneway |
-            | abc   | no     |
-            | bde   | no     |
-
-        Given the query options
-            | waypoints | 1;3   |
-
-        When I match I should get
-            | trace | code         |
-            | abde  | InvalidValue |
-
-    Scenario: Testbot - Map matching with outlier that has no candidate and waypoint parameter
-        Given a grid size of 100 meters
-        Given the node map
-            """
-            a b c d
-
-                1
-            """
-
-        And the ways
-            | nodes | oneway |
-            | abcd  | no     |
-
-        Given the query options
-            | waypoints | 0;2;3   |
-
-        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   |
@@ -69,11 +69,6 @@ inline auto contractExcludableGraph(ContractorGraph contractor_graph_,
                });
            non_core_edges.resize(new_end - non_core_edges.begin());
            edge_container.Insert(std::move(non_core_edges));
-
-            for (const auto filter_index : util::irange<std::size_t>(0, filters.size()))
-            {
-                edge_container.Filter(filters[filter_index], filter_index);
-            }
        }

        // Extract core graph for further contraction
@@ -60,25 +60,6 @@ struct ContractedEdgeContainer
        flags.resize(edges.size(), ALL_FLAGS);
    }

-    void Filter(const std::vector<bool> &filter, std::size_t index)
-    {
-        BOOST_ASSERT(index < sizeof(MergedFlags) * CHAR_BIT);
-        const MergedFlags flag = 1 << index;
-
-        for (auto edge_index : util::irange<std::size_t>(0, edges.size()))
-        {
-            auto allowed = filter[edges[edge_index].source] && filter[edges[edge_index].target];
-            if (allowed)
-            {
-                flags[edge_index] |= flag;
-            }
-            else
-            {
-                flags[edge_index] &= ~flag;
-            }
-        }
-    }
-
    void Merge(std::vector<QueryEdge> new_edges)
    {
        BOOST_ASSERT(index < sizeof(MergedFlags) * CHAR_BIT);
@@ -19,8 +19,7 @@ template <typename QueryGraphT, typename EdgeFilterT>
 inline void readGraph(const boost::filesystem::path &path,
                      unsigned &checksum,
                      QueryGraphT &graph,
-                      std::vector<EdgeFilterT> &edge_filter,
-                      std::uint32_t &connectivity_checksum)
+                      std::vector<EdgeFilterT> &edge_filter)
 {
    static_assert(std::is_same<QueryGraphView, QueryGraphT>::value ||
                      std::is_same<QueryGraph, QueryGraphT>::value,
@@ -40,7 +39,6 @@ inline void readGraph(const boost::filesystem::path &path,
    {
        storage::serialization::read(reader, edge_filter[index]);
    }
-    reader.ReadInto(connectivity_checksum);
 }

 // writes .osrm.hsgr file
@@ -48,8 +46,7 @@ template <typename QueryGraphT, typename EdgeFilterT>
 inline void writeGraph(const boost::filesystem::path &path,
                       unsigned checksum,
                       const QueryGraphT &graph,
-                       const std::vector<EdgeFilterT> &edge_filter,
-                       const std::uint32_t connectivity_checksum)
+                       const std::vector<EdgeFilterT> &edge_filter)
 {
    static_assert(std::is_same<QueryGraphView, QueryGraphT>::value ||
                      std::is_same<QueryGraph, QueryGraphT>::value,
@@ -67,7 +64,6 @@ inline void writeGraph(const boost::filesystem::path &path,
    {
        storage::serialization::write(writer, filter);
    }
-    writer.WriteOne(connectivity_checksum);
 }
 }
 }
@@ -1,12 +1,11 @@
 #ifndef OSRM_CELLS_CUSTOMIZER_HPP
 #define OSRM_CELLS_CUSTOMIZER_HPP

-#include "partitioner/cell_storage.hpp"
-#include "partitioner/multi_level_partition.hpp"
+#include "partition/cell_storage.hpp"
+#include "partition/multi_level_partition.hpp"
 #include "util/query_heap.hpp"

 #include <tbb/enumerable_thread_specific.h>
-#include <tbb/parallel_for.h>

 #include <unordered_set>

@@ -29,12 +28,12 @@ class CellCustomizer
        util::QueryHeap<NodeID, NodeID, EdgeWeight, HeapData, util::ArrayStorage<NodeID, int>>;
    using HeapPtr = tbb::enumerable_thread_specific<Heap>;

-    CellCustomizer(const partitioner::MultiLevelPartition &partition) : partition(partition) {}
+    CellCustomizer(const partition::MultiLevelPartition &partition) : partition(partition) {}

    template <typename GraphT>
    void Customize(const GraphT &graph,
                   Heap &heap,
-                   const partitioner::CellStorage &cells,
+                   const partition::CellStorage &cells,
                   const std::vector<bool> &allowed_nodes,
                   CellMetric &metric,
                   LevelID level,
@@ -97,7 +96,7 @@ class CellCustomizer

    template <typename GraphT>
    void Customize(const GraphT &graph,
-                   const partitioner::CellStorage &cells,
+                   const partition::CellStorage &cells,
                   const std::vector<bool> &allowed_nodes,
                   CellMetric &metric) const
    {
@@ -121,7 +120,7 @@ class CellCustomizer
  private:
    template <typename GraphT>
    void RelaxNode(const GraphT &graph,
-                   const partitioner::CellStorage &cells,
+                   const partition::CellStorage &cells,
                   const std::vector<bool> &allowed_nodes,
                   const CellMetric &metric,
                   Heap &heap,
@@ -209,7 +208,7 @@ class CellCustomizer
        }
    }

-    const partitioner::MultiLevelPartition &partition;
+    const partition::MultiLevelPartition &partition;
 };
 }
 }
@@ -2,8 +2,8 @@
 #define OSRM_CUSTOMIZE_EDGE_BASED_GRAPH_HPP

 #include "extractor/edge_based_edge.hpp"
-#include "partitioner/edge_based_graph.hpp"
-#include "partitioner/multi_level_graph.hpp"
+#include "partition/edge_based_graph.hpp"
+#include "partition/multi_level_graph.hpp"
 #include "util/static_graph.hpp"
 #include "util/typedefs.hpp"

@@ -16,20 +16,19 @@ namespace osrm
 namespace customizer
 {

-using EdgeBasedGraphEdgeData = partitioner::EdgeBasedGraphEdgeData;
+using EdgeBasedGraphEdgeData = partition::EdgeBasedGraphEdgeData;

 struct MultiLevelEdgeBasedGraph
-    : public partitioner::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>
+    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>
 {
-    using Base =
-        partitioner::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
+    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
    using Base::Base;
 };

 struct MultiLevelEdgeBasedGraphView
-    : public partitioner::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>
+    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>
 {
-    using Base = partitioner::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
+    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
    using Base::Base;
 };

@@ -1,7 +1,7 @@
 #ifndef OSRM_CUSTOMIZER_SERIALIZATION_HPP
 #define OSRM_CUSTOMIZER_SERIALIZATION_HPP

-#include "partitioner/cell_storage.hpp"
+#include "partition/cell_storage.hpp"

 #include "storage/io.hpp"
 #include "storage/serialization.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"
@@ -86,10 +86,6 @@ class MatchAPI final : public RouteAPI
            for (auto point_index : util::irange(
                     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.
-                // sub_matching indices: index of the coordinate passed to map matching plugin that
-                // a matched node corresponds to.
                trace_idx_to_matching_idx[tidy_result
                                              .tidied_to_original[sub_matchings[sub_matching_index]
                                                                      .indices[point_index]]] =
@@ -97,9 +93,6 @@ 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()))
        {
            if (tidy_result.can_be_removed[trace_index])
@@ -121,20 +114,6 @@ class MatchAPI final : public RouteAPI
            waypoint.values["alternatives_count"] =
                sub_matchings[matching_index.sub_matching_index]
                    .alternatives_count[matching_index.point_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())
-            {
-                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));
        }

@@ -63,40 +63,25 @@ struct MatchParameters : public RouteParameters
                          RouteParameters::GeometriesType::Polyline,
                          RouteParameters::OverviewType::Simplified,
                          {}),
-          gaps(GapsType::Split), tidy(false), waypoints()
+          gaps(GapsType::Split), tidy(false)
    {
    }

    template <typename... Args>
    MatchParameters(std::vector<unsigned> timestamps_, GapsType gaps_, bool tidy_, Args... args_)
-        : MatchParameters(std::move(timestamps_), gaps_, tidy_, {}, std::forward<Args>(args_)...)
-    {
-    }
-
-    template <typename... Args>
-    MatchParameters(std::vector<unsigned> timestamps_,
-                    GapsType gaps_,
-                    bool tidy_,
-                    std::vector<std::size_t> waypoints_,
-                    Args... args_)
        : RouteParameters{std::forward<Args>(args_)...}, timestamps{std::move(timestamps_)},
-          gaps(gaps_), tidy(tidy_), waypoints{std::move(waypoints_)}
+          gaps(gaps_), tidy(tidy_)
    {
    }

    std::vector<unsigned> timestamps;
    GapsType gaps;
    bool tidy;
-    std::vector<std::size_t> waypoints;

    bool IsValid() const
    {
-        const auto valid_waypoints =
-            std::all_of(waypoints.begin(), waypoints.end(), [this](const auto &w) {
-                return w < coordinates.size();
-            });
        return RouteParameters::IsValid() &&
-               (timestamps.empty() || timestamps.size() == coordinates.size()) && valid_waypoints;
+               (timestamps.empty() || timestamps.size() == coordinates.size());
    }
 };
 }
@@ -37,9 +37,6 @@ struct Result
    Mask can_be_removed;
    // Maps the MatchParameter's original items to items which should not be removed.
    Mapping tidied_to_original;
-    // Masking the MatchParameter coordinates for items whose indices were present in the
-    // `waypoints` parameter.
-    Mask was_waypoint;
 };

 inline Result keep_all(const MatchParameters &params)
@@ -47,17 +44,6 @@ inline Result keep_all(const MatchParameters &params)
    Result result;

    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());
    for (std::size_t current = 0; current < params.coordinates.size(); ++current)
    {
@@ -75,8 +61,6 @@ inline Result keep_all(const MatchParameters &params)
        {
            result.parameters.coordinates.push_back(params.coordinates[i]);

-            if (result.was_waypoint[i])
-                result.parameters.waypoints.push_back(result.parameters.coordinates.size() - 1);
            if (!params.hints.empty())
                result.parameters.hints.push_back(params.hints[i]);

@@ -90,8 +74,6 @@ inline Result keep_all(const MatchParameters &params)
                result.parameters.timestamps.push_back(params.timestamps[i]);
        }
    }
-    if (params.waypoints.empty())
-        result.parameters.waypoints.clear();

    return result;
 }
@@ -103,15 +85,6 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
    Result result;

    result.can_be_removed.resize(params.coordinates.size(), false);
-    result.was_waypoint.resize(params.coordinates.size(), true);
-    if (!params.waypoints.empty())
-    {
-        for (const auto p : params.waypoints)
-        {
-            result.was_waypoint.set(p, false);
-        }
-        result.was_waypoint.flip();
-    }

    result.tidied_to_original.push_back(0);

@@ -165,14 +138,13 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})

    // We have to filter parallel arrays that may be empty or the exact same size.
    // result.parameters contains an empty MatchParameters at this point: conditionally fill.
+
    for (std::size_t i = 0; i < result.can_be_removed.size(); ++i)
    {
        if (!result.can_be_removed[i])
        {
            result.parameters.coordinates.push_back(params.coordinates[i]);

-            if (result.was_waypoint[i])
-                result.parameters.waypoints.push_back(result.parameters.coordinates.size() - 1);
            if (!params.hints.empty())
                result.parameters.hints.push_back(params.hints[i]);

@@ -185,17 +157,8 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
            if (!params.timestamps.empty())
                result.parameters.timestamps.push_back(params.timestamps[i]);
        }
-        else
-        {
-            // one of the coordinates meant to be used as a waypoint was marked for removal
-            // update the original waypoint index to the new representative coordinate
-            const auto last_idx = result.parameters.coordinates.size() - 1;
-            if (result.was_waypoint[i] && (result.parameters.waypoints.back() != last_idx))
-            {
-                result.parameters.waypoints.push_back(last_idx);
-            }
-        }
    }
+    BOOST_ASSERT(result.tidied_to_original.size() == result.parameters.coordinates.size());

    return result;
 }
@@ -1,7 +1,6 @@
 #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"
@@ -20,8 +19,6 @@

 #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"
@@ -91,12 +88,11 @@ class RouteAPI : public BaseAPI
    {
        util::json::Array annotations_store;
        annotations_store.values.reserve(leg.annotations.size());
-
-        for (const auto &step : leg.annotations)
-        {
-            annotations_store.values.push_back(Get(step));
-        }
-
+        std::for_each(leg.annotations.begin(),
+                      leg.annotations.end(),
+                      [Get, &annotations_store](const auto &step) {
+                          annotations_store.values.push_back(Get(step));
+                      });
        return annotations_store;
    }

@@ -133,7 +129,6 @@ class RouteAPI : public BaseAPI
                                             reversed_target,
                                             parameters.steps);

-            util::Log(logDEBUG) << "Assembling steps " << std::endl;
            if (parameters.steps)
            {
                auto steps = guidance::assembleSteps(BaseAPI::facade,
@@ -144,10 +139,6 @@ 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);
-
                /* Perform step-based post-processing.
                 *
                 * Using post-processing on basis of route-steps for a single leg at a time
@@ -264,19 +255,10 @@ 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, [&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);
-                            }
+                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
+                            auto val = std::round(anno.distance / anno.duration * 10.) / 10.;
+                            return util::json::clamp_float(val);
                        });
                }

@@ -311,10 +293,11 @@ class RouteAPI : public BaseAPI
                {
                    util::json::Array nodes;
                    nodes.values.reserve(leg_geometry.osm_node_ids.size());
-                    for (const auto node_id : leg_geometry.osm_node_ids)
-                    {
-                        nodes.values.push_back(static_cast<std::uint64_t>(node_id));
-                    }
+                    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));
+                                  });
                    annotation.values["nodes"] = std::move(nodes);
                }

@@ -5,8 +5,8 @@
 #include "extractor/edge_based_edge.hpp"
 #include "engine/algorithm.hpp"

-#include "partitioner/cell_storage.hpp"
-#include "partitioner/multi_level_partition.hpp"
+#include "partition/cell_storage.hpp"
+#include "partition/multi_level_partition.hpp"

 #include "util/filtered_graph.hpp"
 #include "util/integer_range.hpp"
@@ -75,9 +75,9 @@ template <> class AlgorithmDataFacade<MLD>

    virtual EdgeRange GetAdjacentEdgeRange(const NodeID node) const = 0;

-    virtual const partitioner::MultiLevelPartitionView &GetMultiLevelPartition() const = 0;
+    virtual const partition::MultiLevelPartitionView &GetMultiLevelPartition() const = 0;

-    virtual const partitioner::CellStorageView &GetCellStorage() const = 0;
+    virtual const partition::CellStorageView &GetCellStorage() const = 0;

    virtual const customizer::CellMetricView &GetCellMetric() const = 0;

@@ -13,22 +13,19 @@

 #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/maneuver_override.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_lane_types.hpp"
-
-#include "guidance/turn_bearing.hpp"
-#include "guidance/turn_data_container.hpp"
-#include "guidance/turn_instruction.hpp"
+#include "extractor/turn_data_container.hpp"

 #include "contractor/query_graph.hpp"

-#include "partitioner/cell_storage.hpp"
-#include "partitioner/multi_level_partition.hpp"
+#include "partition/cell_storage.hpp"
+#include "partition/multi_level_partition.hpp"

 #include "storage/shared_datatype.hpp"
 #include "storage/shared_memory_ownership.hpp"
@@ -38,6 +35,7 @@
 #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"
@@ -194,21 +192,18 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    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::TurnLaneType::Mask> m_lane_description_masks;
+    util::vector_view<extractor::guidance::TurnLaneType::Mask> m_lane_description_masks;
    util::vector_view<TurnPenalty> m_turn_weight_penalties;
    util::vector_view<TurnPenalty> m_turn_duration_penalties;
    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;

-    util::vector_view<extractor::StorageManeuverOverride> m_maneuver_overrides;
-    util::vector_view<NodeID> m_maneuver_override_node_sequences;
-
    std::unique_ptr<SharedRTree> m_static_rtree;
    std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
    boost::filesystem::path file_index_path;
@@ -323,9 +318,10 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        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<guidance::TurnInstruction>(
-            memory_ptr, storage::DataLayout::TURN_INSTRUCTION);
-        util::vector_view<guidance::TurnInstruction> turn_instructions(
+        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 =
@@ -333,21 +329,21 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        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<guidance::TurnBearing>(
+        const auto pre_turn_bearing_ptr = layout.GetBlockPtr<util::guidance::TurnBearing>(
            memory_ptr, storage::DataLayout::PRE_TURN_BEARING);
-        util::vector_view<guidance::TurnBearing> pre_turn_bearings(
+        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<guidance::TurnBearing>(
+        const auto post_turn_bearing_ptr = layout.GetBlockPtr<util::guidance::TurnBearing>(
            memory_ptr, storage::DataLayout::POST_TURN_BEARING);
-        util::vector_view<guidance::TurnBearing> post_turn_bearings(
+        util::vector_view<util::guidance::TurnBearing> post_turn_bearings(
            post_turn_bearing_ptr, layout.num_entries[storage::DataLayout::POST_TURN_BEARING]);

-        turn_data = guidance::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));
+        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)
@@ -367,10 +363,10 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
            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::TurnLaneType::Mask>(
+        auto masks_ptr = data_layout.GetBlockPtr<extractor::guidance::TurnLaneType::Mask>(
            memory_block, storage::DataLayout::LANE_DESCRIPTION_MASKS);

-        util::vector_view<extractor::TurnLaneType::Mask> 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);

@@ -503,21 +499,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        m_entry_class_table = std::move(entry_class_table);
    }

-    void InitializeManeuverOverridePointers(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto maneuver_overrides_ptr = data_layout.GetBlockPtr<extractor::StorageManeuverOverride>(
-            memory_block, storage::DataLayout::MANEUVER_OVERRIDES);
-        m_maneuver_overrides = util::vector_view<extractor::StorageManeuverOverride>(
-            maneuver_overrides_ptr,
-            data_layout.num_entries[storage::DataLayout::MANEUVER_OVERRIDES]);
-
-        auto maneuver_override_node_sequences_ptr = data_layout.GetBlockPtr<NodeID>(
-            memory_block, storage::DataLayout::MANEUVER_OVERRIDE_NODE_SEQUENCES);
-        m_maneuver_override_node_sequences = util::vector_view<NodeID>(
-            maneuver_override_node_sequences_ptr,
-            data_layout.num_entries[storage::DataLayout::MANEUVER_OVERRIDE_NODE_SEQUENCES]);
-    }
-
    void InitializeInternalPointers(storage::DataLayout &data_layout,
                                    char *memory_block,
                                    const std::size_t exclude_index)
@@ -534,7 +515,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        InitializeProfilePropertiesPointer(data_layout, memory_block, exclude_index);
        InitializeRTreePointers(data_layout, memory_block);
        InitializeIntersectionClassPointers(data_layout, memory_block);
-        InitializeManeuverOverridePointers(data_layout, memory_block);
    }

  public:
@@ -629,7 +609,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        return m_turn_duration_penalties[id];
    }

-    osrm::guidance::TurnInstruction
+    extractor::guidance::TurnInstruction
    GetTurnInstructionForEdgeID(const EdgeID id) const override final
    {
        return turn_data.GetTurnInstruction(id);
@@ -865,11 +845,11 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        return intersection_bearings_view.GetBearingClass(node);
    }

-    guidance::TurnBearing PreTurnBearing(const EdgeID eid) const override final
+    util::guidance::TurnBearing PreTurnBearing(const EdgeID eid) const override final
    {
        return turn_data.GetPreTurnBearing(eid);
    }
-    guidance::TurnBearing PostTurnBearing(const EdgeID eid) const override final
+    util::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const override final
    {
        return turn_data.GetPostTurnBearing(eid);
    }
@@ -888,13 +868,13 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        return m_lane_tupel_id_pairs.at(turn_data.GetLaneDataID(id));
    }

-    extractor::TurnLaneDescription
+    extractor::guidance::TurnLaneDescription
    GetTurnDescription(const LaneDescriptionID lane_description_id) const override final
    {
        if (lane_description_id == INVALID_LANE_DESCRIPTIONID)
            return {};
        else
-            return extractor::TurnLaneDescription(
+            return extractor::guidance::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]);
@@ -910,39 +890,6 @@ 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;
@@ -965,8 +912,8 @@ class ContiguousInternalMemoryDataFacade<CH>
 template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public AlgorithmDataFacade<MLD>
 {
    // MLD data
-    partitioner::MultiLevelPartitionView mld_partition;
-    partitioner::CellStorageView mld_cell_storage;
+    partition::MultiLevelPartitionView mld_partition;
+    partition::CellStorageView mld_cell_storage;
    customizer::CellMetricView mld_cell_metric;
    using QueryGraph = customizer::MultiLevelEdgeBasedGraphView;
    using GraphNode = QueryGraph::NodeArrayEntry;
@@ -992,7 +939,7 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
            BOOST_ASSERT(data_layout.GetBlockSize(storage::DataLayout::MLD_CELL_TO_CHILDREN) > 0);

            auto level_data =
-                data_layout.GetBlockPtr<partitioner::MultiLevelPartitionView::LevelData>(
+                data_layout.GetBlockPtr<partition::MultiLevelPartitionView::LevelData>(
                    memory_block, storage::DataLayout::MLD_LEVEL_DATA);

            auto mld_partition_ptr = data_layout.GetBlockPtr<PartitionID>(
@@ -1008,7 +955,7 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
            util::vector_view<CellID> cell_to_children(mld_chilren_ptr, children_entries_count);

            mld_partition =
-                partitioner::MultiLevelPartitionView{level_data, partition, cell_to_children};
+                partition::MultiLevelPartitionView{level_data, partition, cell_to_children};
        }

        const auto weights_block_id = static_cast<storage::DataLayout::BlockID>(
@@ -1041,7 +988,7 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
                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<partitioner::CellStorageView::CellData>(
+            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);
@@ -1058,15 +1005,15 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
                                                      source_boundary_entries_count);
            util::vector_view<NodeID> destination_boundary(mld_destination_boundary_ptr,
                                                           destination_boundary_entries_count);
-            util::vector_view<partitioner::CellStorageView::CellData> cells(mld_cells_ptr,
-                                                                            cells_entries_counts);
+            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 = partitioner::CellStorageView{std::move(source_boundary),
-                                                            std::move(destination_boundary),
-                                                            std::move(cells),
-                                                            std::move(level_offsets)};
+            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)
@@ -1103,12 +1050,12 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), exclude_index);
    }

-    const partitioner::MultiLevelPartitionView &GetMultiLevelPartition() const override
+    const partition::MultiLevelPartitionView &GetMultiLevelPartition() const override
    {
        return mld_partition;
    }

-    const partitioner::CellStorageView &GetCellStorage() const override { return mld_cell_storage; }
+    const partition::CellStorageView &GetCellStorage() const override { return mld_cell_storage; }

    const customizer::CellMetricView &GetCellMetric() const override { return mld_cell_metric; }

@@ -10,19 +10,16 @@

 #include "extractor/class_data.hpp"
 #include "extractor/edge_based_node_segment.hpp"
-//#include "extractor/guidance/turn_lane_types.hpp"
-#include "extractor/maneuver_override.hpp"
-//#include "extractor/original_edge_data.hpp"
+#include "extractor/guidance/turn_instruction.hpp"
+#include "extractor/guidance/turn_lane_types.hpp"
+#include "extractor/original_edge_data.hpp"
 #include "extractor/query_node.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/string_util.hpp"
@@ -90,7 +87,8 @@ class BaseDataFacade
    // Gets the name of a datasource
    virtual StringView GetDatasourceName(const DatasourceID id) const = 0;

-    virtual osrm::guidance::TurnInstruction GetTurnInstructionForEdgeID(const EdgeID id) const = 0;
+    virtual extractor::guidance::TurnInstruction
+    GetTurnInstructionForEdgeID(const EdgeID id) const = 0;

    virtual extractor::TravelMode GetTravelMode(const NodeID id) const = 0;

@@ -158,7 +156,7 @@ class BaseDataFacade

    virtual bool HasLaneData(const EdgeID id) const = 0;
    virtual util::guidance::LaneTupleIdPair GetLaneData(const EdgeID id) const = 0;
-    virtual extractor::TurnLaneDescription
+    virtual extractor::guidance::TurnLaneDescription
    GetTurnDescription(const LaneDescriptionID lane_description_id) const = 0;

    virtual NameID GetNameIndex(const NodeID id) const = 0;
@@ -185,8 +183,8 @@ class BaseDataFacade

    virtual double GetWeightMultiplier() 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::TurnBearing PreTurnBearing(const EdgeID eid) const = 0;
+    virtual util::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const = 0;

    virtual util::guidance::BearingClass GetBearingClass(const NodeID node) const = 0;

@@ -195,9 +193,6 @@ 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;
 };
 }
 }
@@ -16,10 +16,10 @@ namespace datafacade
 {

 /**
- * This allocator uses an IPC shared memory block as the data location.
- * Many SharedMemoryDataFacade objects can be created that point to the same shared
- * memory block.
- */
+* This allocator uses an IPC shared memory block as the data location.
+* Many SharedMemoryDataFacade objects can be created that point to the same shared
+* memory block.
+*/
 class SharedMemoryAllocator : public ContiguousBlockAllocator
 {
  public:
@@ -53,12 +53,12 @@ template <typename Algorithm> class Engine final : public EngineInterface
 {
  public:
    explicit Engine(const EngineConfig &config)
-        : route_plugin(config.max_locations_viaroute, config.max_alternatives),            //
-          table_plugin(config.max_locations_distance_table),                               //
-          nearest_plugin(config.max_results_nearest),                                      //
-          trip_plugin(config.max_locations_trip),                                          //
-          match_plugin(config.max_locations_map_matching, config.max_radius_map_matching), //
-          tile_plugin()                                                                    //
+        : route_plugin(config.max_locations_viaroute, config.max_alternatives), //
+          table_plugin(config.max_locations_distance_table),                    //
+          nearest_plugin(config.max_results_nearest),                           //
+          trip_plugin(config.max_locations_trip),                               //
+          match_plugin(config.max_locations_map_matching),                      //
+          tile_plugin()                                                         //

    {
        if (config.use_shared_memory)
@@ -84,7 +84,6 @@ struct EngineConfig final
    int max_locations_viaroute = -1;
    int max_locations_distance_table = -1;
    int max_locations_map_matching = -1;
-    double max_radius_map_matching = -1.0;
    int max_results_nearest = -1;
    int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
    bool use_shared_memory = true;
@@ -79,7 +79,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    {
        auto results = rtree.Nearest(
            input_coordinate,
-            [this, approach, &input_coordinate, bearing, bearing_range](
+            [this, approach, &input_coordinate, bearing, bearing_range, max_distance](
                const CandidateSegment &segment) {
                auto use_direction =
                    boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range),
@@ -1,8 +1,8 @@
 #ifndef ENGINE_GUIDANCE_ASSEMBLE_GEOMETRY_HPP
 #define ENGINE_GUIDANCE_ASSEMBLE_GEOMETRY_HPP

+#include "extractor/guidance/turn_instruction.hpp"
 #include "extractor/travel_mode.hpp"
-#include "guidance/turn_instruction.hpp"
 #include "engine/datafacade/datafacade_base.hpp"
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
@@ -70,7 +70,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
        cumulative_distance += current_distance;

        // all changes to this check have to be matched with assemble_steps
-        if (path_point.turn_instruction.type != osrm::guidance::TurnType::NoTurn)
+        if (path_point.turn_instruction.type != extractor::guidance::TurnType::NoTurn)
        {
            geometry.segment_distances.push_back(cumulative_distance);
            geometry.segment_offsets.push_back(geometry.locations.size());
@@ -1,9 +1,9 @@
 #ifndef ENGINE_GUIDANCE_ASSEMBLE_STEPS_HPP_
 #define ENGINE_GUIDANCE_ASSEMBLE_STEPS_HPP_

+#include "extractor/guidance/turn_instruction.hpp"
+#include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/travel_mode.hpp"
-#include "extractor/turn_lane_types.hpp"
-#include "guidance/turn_instruction.hpp"
 #include "engine/datafacade/datafacade_base.hpp"
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
@@ -83,7 +83,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
    StepManeuver maneuver{source_node.location,
                          bearings.first,
                          bearings.second,
-                          osrm::guidance::TurnInstruction::NO_TURN(),
+                          extractor::guidance::TurnInstruction::NO_TURN(),
                          WaypointType::Depart,
                          0};

@@ -115,7 +115,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
            segment_weight += path_point.weight_until_turn;

            // all changes to this check have to be matched with assemble_geometry
-            if (path_point.turn_instruction.type != osrm::guidance::TurnType::NoTurn)
+            if (path_point.turn_instruction.type != extractor::guidance::TurnType::NoTurn)
            {
                BOOST_ASSERT(segment_weight >= 0);
                const auto name = facade.GetNameForID(step_name_id);
@@ -127,8 +127,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                // intersections contain the classes of exiting road
                intersection.classes = facade.GetClasses(path_point.classes);

-                steps.push_back(RouteStep{path_point.from_edge_based_node,
-                                          step_name_id,
+                steps.push_back(RouteStep{step_name_id,
                                          is_segregated,
                                          name.to_string(),
                                          ref.to_string(),
@@ -172,7 +171,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                intersection.lane_description =
                    path_point.lane_data.second != INVALID_LANE_DESCRIPTIONID
                        ? facade.GetTurnDescription(path_point.lane_data.second)
-                        : extractor::TurnLaneDescription();
+                        : extractor::guidance::TurnLaneDescription();

                // Lanes in turn are bound by total number of lanes at the location
                BOOST_ASSERT(intersection.lanes.lanes_in_turn <=
@@ -210,8 +209,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
        // intersections contain the classes of exiting road
        intersection.classes = facade.GetClasses(facade.GetClassData(target_node_id));
        BOOST_ASSERT(duration >= 0);
-        steps.push_back(RouteStep{leg_data[leg_data.size() - 1].from_edge_based_node,
-                                  step_name_id,
+        steps.push_back(RouteStep{step_name_id,
                                  is_segregated,
                                  facade.GetNameForID(step_name_id).to_string(),
                                  facade.GetRefForID(step_name_id).to_string(),
@@ -255,8 +253,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
        BOOST_ASSERT(target_duration >= source_duration || weight == 0);
        const EdgeWeight duration = std::max(0, target_duration - source_duration);

-        steps.push_back(RouteStep{source_node_id,
-                                  source_name_id,
+        steps.push_back(RouteStep{source_name_id,
                                  is_segregated,
                                  facade.GetNameForID(source_name_id).to_string(),
                                  facade.GetRefForID(source_name_id).to_string(),
@@ -293,13 +290,12 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
    maneuver = {intersection.location,
                bearings.first,
                bearings.second,
-                osrm::guidance::TurnInstruction::NO_TURN(),
+                extractor::guidance::TurnInstruction::NO_TURN(),
                WaypointType::Arrive,
                0};

    BOOST_ASSERT(!leg_geometry.locations.empty());
-    steps.push_back(RouteStep{target_node_id,
-                              target_name_id,
+    steps.push_back(RouteStep{target_name_id,
                              facade.IsSegregated(target_node_id),
                              facade.GetNameForID(target_name_id).to_string(),
                              facade.GetRefForID(target_name_id).to_string(),
@@ -77,10 +77,10 @@ struct AdjustToCombinedTurnStrategy : CombineStrategy
 // Set a fixed instruction type
 struct SetFixedInstructionStrategy : CombineStrategy
 {
-    SetFixedInstructionStrategy(const osrm::guidance::TurnInstruction instruction);
+    SetFixedInstructionStrategy(const extractor::guidance::TurnInstruction instruction);
    void operator()(RouteStep &step_at_turn_location, const RouteStep &transfer_from_step) const;

-    const osrm::guidance::TurnInstruction instruction;
+    const extractor::guidance::TurnInstruction instruction;
 };

 // Handling of staggered intersections
@@ -1,7 +1,7 @@
 #ifndef OSRM_ENGINE_GUIDANCE_COLLAPSING_UTILITY_HPP_
 #define OSRM_ENGINE_GUIDANCE_COLLAPSING_UTILITY_HPP_

-#include "guidance/turn_instruction.hpp"
+#include "extractor/guidance/turn_instruction.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "util/attributes.hpp"
 #include "util/bearing.hpp"
@@ -10,6 +10,9 @@
 #include <boost/range/algorithm_ext/erase.hpp>
 #include <cstddef>

+using osrm::extractor::guidance::TurnInstruction;
+using namespace osrm::extractor::guidance;
+
 namespace osrm
 {
 namespace engine
@@ -27,7 +30,7 @@ const constexpr double NAME_SEGMENT_CUTOFF_LENGTH = 105.0;
 // check if a step is completely without turn type
 inline bool hasTurnType(const RouteStep &step)
 {
-    return step.maneuver.instruction.type != osrm::guidance::TurnType::NoTurn;
+    return step.maneuver.instruction.type != TurnType::NoTurn;
 }
 inline bool hasWaypointType(const RouteStep &step)
 {
@@ -64,13 +67,12 @@ inline RouteStepIterator findNextTurn(RouteStepIterator current_step)
 }

 // alias for comparisons
-inline bool hasTurnType(const RouteStep &step, const osrm::guidance::TurnType::Enum type)
+inline bool hasTurnType(const RouteStep &step, const TurnType::Enum type)
 {
    return type == step.maneuver.instruction.type;
 }
 // alias for comparisons
-inline bool hasModifier(const RouteStep &step,
-                        const osrm::guidance::DirectionModifier::Enum modifier)
+inline bool hasModifier(const RouteStep &step, const DirectionModifier::Enum modifier)
 {
    return modifier == step.maneuver.instruction.direction_modifier;
 }
@@ -94,12 +96,12 @@ inline std::size_t numberOfAllowedTurns(const RouteStep &step)
 // fulfill:
 inline bool isTrafficLightStep(const RouteStep &step)
 {
-    return hasTurnType(step, osrm::guidance::TurnType::Suppressed) &&
-           numberOfAvailableTurns(step) == 2 && numberOfAllowedTurns(step) == 1;
+    return hasTurnType(step, TurnType::Suppressed) && numberOfAvailableTurns(step) == 2 &&
+           numberOfAllowedTurns(step) == 1;
 }

 // alias for readability
-inline void setInstructionType(RouteStep &step, const osrm::guidance::TurnType::Enum type)
+inline void setInstructionType(RouteStep &step, const TurnType::Enum type)
 {
    step.maneuver.instruction.type = type;
 }
@@ -149,12 +151,12 @@ inline bool haveSameName(const RouteStep &lhs, const RouteStep &rhs)
 inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
 {
    const auto is_left = [](const RouteStep &step) {
-        return hasModifier(step, osrm::guidance::DirectionModifier::Straight) ||
+        return hasModifier(step, DirectionModifier::Straight) ||
               hasLeftModifier(step.maneuver.instruction);
    };

    const auto is_right = [](const RouteStep &step) {
-        return hasModifier(step, osrm::guidance::DirectionModifier::Straight) ||
+        return hasModifier(step, DirectionModifier::Straight) ||
               hasRightModifier(step.maneuver.instruction);
    };

@@ -172,7 +174,7 @@ inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> st

    // keep valid instructions
    const auto not_is_valid = [](const RouteStep &step) {
-        return step.maneuver.instruction == osrm::guidance::TurnInstruction::NO_TURN() &&
+        return step.maneuver.instruction == TurnInstruction::NO_TURN() &&
               step.maneuver.waypoint_type == WaypointType::None;
    };

@@ -1,7 +1,6 @@
 #ifndef ENGINE_GUIDANCE_POST_PROCESSING_HPP
 #define ENGINE_GUIDANCE_POST_PROCESSING_HPP

-#include "engine/datafacade/datafacade_base.hpp"
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "engine/phantom_node.hpp"
@@ -46,18 +45,6 @@ std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
 OSRM_ATTR_WARN_UNUSED
 LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps);

-/**
- * Apply maneuver override relations to the selected route.
- * Should be called before any other post-processing is performed
- * to ensure that all sequences of edge-based-nodes are still in the
- * steps list.
- *
- * @param steps the steps of the route
- */
-void applyOverrides(const datafacade::BaseDataFacade &facade,
-                    std::vector<RouteStep> &steps,
-                    const LegGeometry &geometry);
-
 } // namespace guidance
 } // namespace engine
 } // namespace osrm
@@ -1,7 +1,7 @@
 #ifndef OSRM_ENGINE_GUIDANCE_POSTPROCESSING_TOOLKIT_HPP_
 #define OSRM_ENGINE_GUIDANCE_POSTPROCESSING_TOOLKIT_HPP_

-#include "guidance/turn_instruction.hpp"
+#include "extractor/guidance/turn_instruction.hpp"
 #include "engine/guidance/route_step.hpp"

 #include <iterator>
@@ -7,7 +7,7 @@
 #include "util/guidance/bearing_class.hpp"
 #include "util/guidance/entry_class.hpp"

-#include "extractor/turn_lane_types.hpp"
+#include "extractor/guidance/turn_lane_types.hpp"
 #include "util/guidance/turn_lanes.hpp"

 #include <cstddef>
@@ -41,7 +41,7 @@ struct IntermediateIntersection

    // turn lane information
    util::guidance::LaneTuple lanes;
-    extractor::TurnLaneDescription lane_description;
+    extractor::guidance::TurnLaneDescription lane_description;
    std::vector<std::string> classes;
 };

@@ -59,7 +59,6 @@ inline IntermediateIntersection getInvalidIntersection()

 struct RouteStep
 {
-    NodeID from_id;
    unsigned name_id;
    bool is_segregated;
    std::string name;
@@ -1,7 +1,7 @@
 #ifndef ENGINE_GUIDANCE_STEP_MANEUVER_HPP
 #define ENGINE_GUIDANCE_STEP_MANEUVER_HPP

-#include "guidance/turn_instruction.hpp"
+#include "extractor/guidance/turn_instruction.hpp"
 #include "util/coordinate.hpp"

 #include <cstdint>
@@ -28,7 +28,7 @@ struct StepManeuver
    util::Coordinate location;
    short bearing_before;
    short bearing_after;
-    osrm::guidance::TurnInstruction instruction;
+    extractor::guidance::TurnInstruction instruction;

    WaypointType waypoint_type;
    unsigned exit;
@@ -39,7 +39,7 @@ inline StepManeuver getInvalidStepManeuver()
    return {util::Coordinate{util::FloatLongitude{0.0}, util::FloatLatitude{0.0}},
            0,
            0,
-            osrm::guidance::TurnInstruction::NO_TURN(),
+            extractor::guidance::TurnInstruction::NO_TURN(),
            WaypointType::None,
            0};
 }
@@ -2,17 +2,16 @@
 #define RAW_ROUTE_DATA_H

 #include "extractor/class_data.hpp"
+#include "extractor/guidance/turn_instruction.hpp"
 #include "extractor/travel_mode.hpp"

-#include "guidance/turn_bearing.hpp"
-#include "guidance/turn_instruction.hpp"
-
 #include "engine/phantom_node.hpp"

-#include "util/coordinate.hpp"
+#include "osrm/coordinate.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/typedefs.hpp"

 #include <vector>
@@ -24,9 +23,7 @@ namespace engine

 struct PathData
 {
-    // from edge-based-node id
-    NodeID from_edge_based_node;
-    // the internal OSRM id of the OSM node id that is the via node of the turn
+    // id of via node of the turn
    NodeID turn_via_node;
    // name of the street that leads to the turn
    unsigned name_id;
@@ -45,7 +42,7 @@ struct PathData
    // will contain the duration of the turn.  Otherwise it will be 0.
    EdgeWeight duration_of_turn;
    // instruction to execute at the turn
-    osrm::guidance::TurnInstruction turn_instruction;
+    extractor::guidance::TurnInstruction turn_instruction;
    // turn lane data
    util::guidance::LaneTupleIdPair lane_data;
    // travel mode of the street that leads to the turn
@@ -59,9 +56,9 @@ struct PathData
    DatasourceID datasource_id;

    // bearing (as seen from the intersection) pre-turn
-    osrm::guidance::TurnBearing pre_turn_bearing;
+    util::guidance::TurnBearing pre_turn_bearing;
    // bearing (as seen from the intersection) post-turn
-    osrm::guidance::TurnBearing post_turn_bearing;
+    util::guidance::TurnBearing post_turn_bearing;

    // Driving side of the turn
    bool is_left_hand_driving;
@@ -105,53 +102,6 @@ struct InternalManyRoutesResult

    std::vector<InternalRouteResult> routes;
 };
-
-inline InternalRouteResult CollapseInternalRouteResult(const InternalRouteResult &leggy_result,
-                                                       const std::vector<bool> &is_waypoint)
-{
-    BOOST_ASSERT(leggy_result.is_valid());
-    BOOST_ASSERT(is_waypoint[0]);     // first and last coords
-    BOOST_ASSERT(is_waypoint.back()); // should always be waypoints
-    // Nothing to collapse! return result as is
-    if (leggy_result.unpacked_path_segments.size() == 1)
-        return leggy_result;
-
-    BOOST_ASSERT(leggy_result.segment_end_coordinates.size() > 1);
-
-    InternalRouteResult collapsed;
-    collapsed.shortest_path_weight = leggy_result.shortest_path_weight;
-    for (auto i : util::irange<std::size_t>(0, leggy_result.unpacked_path_segments.size()))
-    {
-        if (is_waypoint[i])
-        {
-            // start another leg vector
-            collapsed.unpacked_path_segments.push_back(leggy_result.unpacked_path_segments[i]);
-            // save new phantom node pair
-            collapsed.segment_end_coordinates.push_back(leggy_result.segment_end_coordinates[i]);
-            // save data about phantom nodes
-            collapsed.source_traversed_in_reverse.push_back(
-                leggy_result.source_traversed_in_reverse[i]);
-            collapsed.target_traversed_in_reverse.push_back(
-                leggy_result.target_traversed_in_reverse[i]);
-        }
-        else
-        // no new leg, collapse the next segment into the last leg
-        {
-            BOOST_ASSERT(!collapsed.unpacked_path_segments.empty());
-            auto &last_segment = collapsed.unpacked_path_segments.back();
-            BOOST_ASSERT(!collapsed.segment_end_coordinates.empty());
-            collapsed.segment_end_coordinates.back().target_phantom =
-                leggy_result.segment_end_coordinates[i].target_phantom;
-            collapsed.target_traversed_in_reverse.back() =
-                leggy_result.target_traversed_in_reverse[i];
-            // copy path segments into current leg
-            last_segment.insert(last_segment.end(),
-                                leggy_result.unpacked_path_segments[i].begin(),
-                                leggy_result.unpacked_path_segments[i].end());
-        }
-    }
-    return collapsed;
-}
 }
 }

@@ -25,17 +25,21 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#ifndef OSRM_ENGINE_PHANTOM_NODES_H
-#define OSRM_ENGINE_PHANTOM_NODES_H
+#ifndef PHANTOM_NODES_H
+#define PHANTOM_NODES_H

 #include "extractor/travel_mode.hpp"
+#include "util/typedefs.hpp"

 #include "util/bearing.hpp"
 #include "util/coordinate.hpp"
-#include "util/typedefs.hpp"

 #include <boost/assert.hpp>

+#include <iostream>
+#include <utility>
+#include <vector>
+
 namespace osrm
 {
 namespace engine
@@ -195,6 +199,31 @@ struct PhantomNodes
    PhantomNode source_phantom;
    PhantomNode target_phantom;
 };
+
+inline std::ostream &operator<<(std::ostream &out, const PhantomNodes &pn)
+{
+    out << "source_coord: " << pn.source_phantom.location << "\n";
+    out << "target_coord: " << pn.target_phantom.location << std::endl;
+    return out;
+}
+
+inline std::ostream &operator<<(std::ostream &out, const PhantomNode &pn)
+{
+    out << "node1: " << pn.forward_segment_id.id << ", "
+        << "node2: " << pn.reverse_segment_id.id << ", "
+        << "fwd-w: " << pn.forward_weight << ", "
+        << "rev-w: " << pn.reverse_weight << ", "
+        << "fwd-o: " << pn.forward_weight_offset << ", "
+        << "rev-o: " << pn.reverse_weight_offset << ", "
+        << "fwd-d: " << pn.forward_duration << ", "
+        << "rev-d: " << pn.reverse_duration << ", "
+        << "fwd-do: " << pn.forward_duration_offset << ", "
+        << "rev-do: " << pn.reverse_duration_offset << ", "
+        << "comp: " << pn.component.is_tiny << " / " << pn.component.id << ", "
+        << "pos: " << pn.fwd_segment_position << ", "
+        << "loc: " << pn.location;
+    return out;
+}
 }
 }

@@ -24,9 +24,8 @@ class MatchPlugin : public BasePlugin
    using CandidateLists = routing_algorithms::CandidateLists;
    static const constexpr double RADIUS_MULTIPLIER = 3;

-    MatchPlugin(const int max_locations_map_matching, const double max_radius_map_matching)
-        : max_locations_map_matching(max_locations_map_matching),
-          max_radius_map_matching(max_radius_map_matching)
+    MatchPlugin(const int max_locations_map_matching)
+        : max_locations_map_matching(max_locations_map_matching)
    {
    }

@@ -36,7 +35,6 @@ class MatchPlugin : public BasePlugin

  private:
    const int max_locations_map_matching;
-    const double max_radius_map_matching;
 };
 }
 }
@@ -1,8 +1,7 @@
 #ifndef OSRM_ENGINE_ROUTING_BASE_HPP
 #define OSRM_ENGINE_ROUTING_BASE_HPP

-#include "guidance/turn_bearing.hpp"
-#include "guidance/turn_instruction.hpp"
+#include "extractor/guidance/turn_instruction.hpp"

 #include "engine/algorithm.hpp"
 #include "engine/datafacade.hpp"
@@ -11,6 +10,7 @@
 #include "engine/search_engine_data.hpp"

 #include "util/coordinate_calculation.hpp"
+#include "util/guidance/turn_bearing.hpp"
 #include "util/typedefs.hpp"

 #include <boost/assert.hpp>
@@ -192,22 +192,21 @@ void annotatePath(const FacadeT &facade,
        BOOST_ASSERT(start_index < end_index);
        for (std::size_t segment_idx = start_index; segment_idx < end_index; ++segment_idx)
        {
-            unpacked_path.push_back(PathData{*node_from,
-                                             id_vector[segment_idx + 1],
+            unpacked_path.push_back(PathData{id_vector[segment_idx + 1],
                                             name_index,
                                             is_segregated,
                                             weight_vector[segment_idx],
                                             0,
                                             duration_vector[segment_idx],
                                             0,
-                                             guidance::TurnInstruction::NO_TURN(),
+                                             extractor::guidance::TurnInstruction::NO_TURN(),
                                             {{0, INVALID_LANEID}, INVALID_LANE_DESCRIPTIONID},
                                             travel_mode,
                                             classes,
                                             EMPTY_ENTRY_CLASS,
                                             datasource_vector[segment_idx],
-                                             osrm::guidance::TurnBearing(0),
-                                             osrm::guidance::TurnBearing(0),
+                                             util::guidance::TurnBearing(0),
+                                             util::guidance::TurnBearing(0),
                                             is_left_hand_driving});
        }
        BOOST_ASSERT(unpacked_path.size() > 0);
@@ -267,22 +266,21 @@ void annotatePath(const FacadeT &facade,
        BOOST_ASSERT(segment_idx < id_vector.size() - 1);
        BOOST_ASSERT(facade.GetTravelMode(target_node_id) > 0);
        unpacked_path.push_back(
-            PathData{target_node_id,
-                     id_vector[start_index < end_index ? segment_idx + 1 : segment_idx - 1],
+            PathData{id_vector[start_index < end_index ? segment_idx + 1 : segment_idx - 1],
                     facade.GetNameIndex(target_node_id),
                     facade.IsSegregated(target_node_id),
                     weight_vector[segment_idx],
                     0,
                     duration_vector[segment_idx],
                     0,
-                     guidance::TurnInstruction::NO_TURN(),
+                     extractor::guidance::TurnInstruction::NO_TURN(),
                     {{0, INVALID_LANEID}, INVALID_LANE_DESCRIPTIONID},
                     facade.GetTravelMode(target_node_id),
                     facade.GetClassData(target_node_id),
                     EMPTY_ENTRY_CLASS,
                     datasource_vector[segment_idx],
-                     guidance::TurnBearing(0),
-                     guidance::TurnBearing(0),
+                     util::guidance::TurnBearing(0),
+                     util::guidance::TurnBearing(0),
                     is_target_left_hand_driving});
    }

@@ -24,7 +24,7 @@ struct TurnData final
    const int turn_angle;
    const EdgeWeight weight;
    const EdgeWeight duration;
-    const guidance::TurnInstruction turn_instruction;
+    const extractor::guidance::TurnInstruction turn_instruction;
 };

 using RTreeLeaf = datafacade::BaseDataFacade::RTreeLeaf;
@@ -10,6 +10,8 @@
 #include <string>
 #include <vector>

+#include <boost/optional.hpp>
+
 namespace osrm
 {
 namespace extractor
@@ -39,8 +41,8 @@ class CompressedEdgeContainer
                      const EdgeDuration duration2,
                      // node-penalties can be added before/or after the traversal of an edge which
                      // depends on whether we traverse the link forwards or backwards.
-                      const EdgeWeight node_weight_penalty = INVALID_EDGE_WEIGHT,
-                      const EdgeDuration node_duration_penalty = MAXIMAL_EDGE_DURATION);
+                      const boost::optional<EdgeWeight> node_weight_penalty = boost::none,
+                      const boost::optional<EdgeDuration> node_duration_penalty = boost::none);

    void AddUncompressedEdge(const EdgeID edge_id,
                             const NodeID target_node,
@@ -8,15 +8,15 @@
 #include "extractor/edge_based_edge.hpp"
 #include "extractor/edge_based_node_segment.hpp"
 #include "extractor/extraction_turn.hpp"
-#include "extractor/maneuver_override.hpp"
+#include "extractor/guidance/turn_analysis.hpp"
+#include "extractor/guidance/turn_instruction.hpp"
+#include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/nbg_to_ebg.hpp"
 #include "extractor/node_data_container.hpp"
+#include "extractor/original_edge_data.hpp"
 #include "extractor/query_node.hpp"
 #include "extractor/restriction_index.hpp"
-#include "extractor/turn_lane_types.hpp"
 #include "extractor/way_restriction_map.hpp"
-#include "guidance/turn_analysis.hpp"
-#include "guidance/turn_instruction.hpp"

 #include "util/concurrent_id_map.hpp"
 #include "util/deallocating_vector.hpp"
@@ -76,26 +76,31 @@ class EdgeBasedGraphFactory
                                   const std::vector<util::Coordinate> &coordinates,
                                   const util::NameTable &name_table,
                                   const std::unordered_set<EdgeID> &segregated_edges,
-                                   const LaneDescriptionMap &lane_description_map);
+                                   guidance::LaneDescriptionMap &lane_description_map);

    void Run(ScriptingEnvironment &scripting_environment,
+             const std::string &turn_data_filename,
+             const std::string &turn_lane_data_filename,
             const std::string &turn_weight_penalties_filename,
             const std::string &turn_duration_penalties_filename,
             const std::string &turn_penalties_index_filename,
             const std::string &cnbg_ebg_mapping_path,
             const std::string &conditional_penalties_filename,
-             const std::string &maneuver_overrides_filename,
             const RestrictionMap &node_restriction_map,
             const ConditionalRestrictionMap &conditional_restriction_map,
-             const WayRestrictionMap &way_restriction_map,
-             const std::vector<UnresolvedManeuverOverride> &maneuver_overrides);
+             const WayRestrictionMap &way_restriction_map);

    // The following get access functions destroy the content in the factory
    void GetEdgeBasedEdges(util::DeallocatingVector<EdgeBasedEdge> &edges);
    void GetEdgeBasedNodeSegments(std::vector<EdgeBasedNodeSegment> &nodes);
    void GetStartPointMarkers(std::vector<bool> &node_is_startpoint);
    void GetEdgeBasedNodeWeights(std::vector<EdgeWeight> &output_node_weights);
-    std::uint32_t GetConnectivityChecksum() const;
+
+    // These access functions don't destroy the content
+    const std::vector<BearingClassID> &GetBearingClassIds() const;
+    std::vector<BearingClassID> &GetBearingClassIds();
+    std::vector<util::guidance::BearingClass> GetBearingClasses() const;
+    std::vector<util::guidance::EntryClass> GetEntryClasses() const;

    std::uint64_t GetNumberOfEdgeBasedNodes() const;

@@ -137,7 +142,6 @@ class EdgeBasedGraphFactory
    std::vector<EdgeBasedNodeSegment> m_edge_based_node_segments;
    EdgeBasedNodeDataContainer &m_edge_based_node_container;
    util::DeallocatingVector<EdgeBasedEdge> m_edge_based_edge_list;
-    std::uint32_t m_connectivity_checksum;

    // The number of edge-based nodes is mostly made up out of the edges in the node-based graph.
    // Any edge in the node-based graph represents a node in the edge-based graph. In addition, we
@@ -155,7 +159,7 @@ class EdgeBasedGraphFactory

    const util::NameTable &name_table;
    const std::unordered_set<EdgeID> &segregated_edges;
-    const LaneDescriptionMap &lane_description_map;
+    guidance::LaneDescriptionMap &lane_description_map;

    // In the edge based graph, any traversable (non reversed) edge of the node-based graph forms a
    // node of the edge-based graph. To be able to name these nodes, we loop over the node-based
@@ -171,22 +175,28 @@ class EdgeBasedGraphFactory

    // Edge-expanded edges are generate for all valid turns. The validity can be checked via the
    // restriction maps
-    void
-    GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment,
-                              const std::string &turn_weight_penalties_filename,
-                              const std::string &turn_duration_penalties_filename,
-                              const std::string &turn_penalties_index_filename,
-                              const std::string &conditional_turn_penalties_filename,
-                              const std::string &maneuver_overrides_filename,
-                              const RestrictionMap &node_restriction_map,
-                              const ConditionalRestrictionMap &conditional_restriction_map,
-                              const WayRestrictionMap &way_restriction_map,
-                              const std::vector<UnresolvedManeuverOverride> &maneuver_overrides);
+    void GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment,
+                                   const std::string &original_edge_data_filename,
+                                   const std::string &turn_lane_data_filename,
+                                   const std::string &turn_weight_penalties_filename,
+                                   const std::string &turn_duration_penalties_filename,
+                                   const std::string &turn_penalties_index_filename,
+                                   const std::string &conditional_turn_penalties_filename,
+                                   const RestrictionMap &node_restriction_map,
+                                   const ConditionalRestrictionMap &conditional_restriction_map,
+                                   const WayRestrictionMap &way_restriction_map);

    NBGToEBG InsertEdgeBasedNode(const NodeID u, const NodeID v);

+    std::size_t restricted_turns_counter;
+    std::size_t skipped_uturns_counter;
+    std::size_t skipped_barrier_turns_counter;
+
    // mapping of node-based edges to edge-based nodes
    std::vector<NodeID> nbe_to_ebn_mapping;
+    util::ConcurrentIDMap<util::guidance::BearingClass, BearingClassID> bearing_class_hash;
+    std::vector<BearingClassID> bearing_class_by_node_based_node;
+    util::ConcurrentIDMap<util::guidance::EntryClass, EntryClassID> entry_class_hash;
 };
 } // namespace extractor
 } // namespace osrm
@@ -23,7 +23,6 @@ namespace extractor
 class ExtractionContainers
 {
    void PrepareNodes();
-    void PrepareManeuverOverrides();
    void PrepareRestrictions();
    void PrepareEdges(ScriptingEnvironment &scripting_environment);

@@ -64,9 +63,6 @@ class ExtractionContainers
    std::vector<ConditionalTurnRestriction> conditional_turn_restrictions;
    std::vector<TurnRestriction> unconditional_turn_restrictions;

-    std::vector<InputManeuverOverride> external_maneuver_overrides_list;
-    std::vector<UnresolvedManeuverOverride> internal_maneuver_overrides;
-
    ExtractionContainers();

    void PrepareData(ScriptingEnvironment &scripting_environment,
@@ -12,7 +12,7 @@
 #include <limits>
 #include <string>

-#include "guidance/parsing_toolkit.hpp"
+#include "extractor/guidance/parsing_toolkit.hpp"

 namespace osrm
 {
@@ -35,10 +35,10 @@ template <typename Iterator> struct iso_8601_grammar : qi::grammar<Iterator, uns
        using qi::_c;
        using qi::_pass;
        using qi::_val;
-        using qi::char_;
        using qi::eoi;
        using qi::eps;
        using qi::uint_;
+        using qi::char_;

        hh = uint2_p[_pass = bind([](unsigned x) { return x < 24; }, _1), _val = _1];
        mm = uint2_p[_pass = bind([](unsigned x) { return x < 60; }, _1), _val = _1];
@@ -1,11 +1,10 @@
 #ifndef OSRM_EXTRACTION_TURN_HPP
 #define OSRM_EXTRACTION_TURN_HPP

-#include "extractor/road_classification.hpp"
-#include "extractor/travel_mode.hpp"
-
 #include <boost/numeric/conversion/cast.hpp>

+#include <extractor/guidance/intersection.hpp>
+
 #include <cstdint>

 namespace osrm
@@ -13,122 +12,35 @@ namespace osrm
 namespace extractor
 {

-struct ExtractionTurnLeg
-{
-    ExtractionTurnLeg(bool is_restricted,
-                      bool is_motorway,
-                      bool is_link,
-                      int number_of_lanes,
-                      int highway_turn_classification,
-                      int access_turn_classification,
-                      int speed,
-                      RoadPriorityClass::Enum priority_class,
-                      bool is_incoming,
-                      bool is_outgoing)
-        : is_restricted(is_restricted), is_motorway(is_motorway), is_link(is_link),
-          number_of_lanes(number_of_lanes),
-          highway_turn_classification(highway_turn_classification),
-          access_turn_classification(access_turn_classification), speed(speed),
-          priority_class(priority_class), is_incoming(is_incoming), is_outgoing(is_outgoing)
-    {
-    }
-
-    const bool is_restricted;
-    const bool is_motorway;
-    const bool is_link;
-    const int number_of_lanes;
-    const int highway_turn_classification;
-    const int access_turn_classification;
-    const int speed;
-    const RoadPriorityClass::Enum priority_class;
-    const bool is_incoming;
-    const bool is_outgoing;
-};
-
 struct ExtractionTurn
 {
    ExtractionTurn(double angle,
                   int number_of_roads,
                   bool is_u_turn,
                   bool has_traffic_light,
-                   bool is_left_hand_driving,
                   bool source_restricted,
-                   TravelMode source_mode,
-                   bool source_is_motorway,
-                   bool source_is_link,
-                   int source_number_of_lanes,
-                   int source_highway_turn_classification,
-                   int source_access_turn_classification,
-                   int source_speed,
-                   RoadPriorityClass::Enum source_priority_class,
-
                   bool target_restricted,
-                   TravelMode target_mode,
-                   bool target_is_motorway,
-                   bool target_is_link,
-                   int target_number_of_lanes,
-                   int target_highway_turn_classification,
-                   int target_access_turn_classification,
-                   int target_speed,
-                   RoadPriorityClass::Enum target_priority_class,
-
-                   const std::vector<ExtractionTurnLeg> &roads_on_the_right,
-                   const std::vector<ExtractionTurnLeg> &roads_on_the_left)
+                   bool is_left_hand_driving,
+                   TravelMode source_mode,
+                   TravelMode target_mode)
        : angle(180. - angle), number_of_roads(number_of_roads), is_u_turn(is_u_turn),
-          has_traffic_light(has_traffic_light), is_left_hand_driving(is_left_hand_driving),
-
-          source_restricted(source_restricted), source_mode(source_mode),
-          source_is_motorway(source_is_motorway), source_is_link(source_is_link),
-          source_number_of_lanes(source_number_of_lanes),
-          source_highway_turn_classification(source_highway_turn_classification),
-          source_access_turn_classification(source_access_turn_classification),
-          source_speed(source_speed), source_priority_class(source_priority_class),
-
-          target_restricted(target_restricted), target_mode(target_mode),
-          target_is_motorway(target_is_motorway), target_is_link(target_is_link),
-          target_number_of_lanes(target_number_of_lanes),
-          target_highway_turn_classification(target_highway_turn_classification),
-          target_access_turn_classification(target_access_turn_classification),
-          target_speed(target_speed), target_priority_class(target_priority_class),
-
-          roads_on_the_right(roads_on_the_right), roads_on_the_left(roads_on_the_left), weight(0.),
-          duration(0.)
-
+          has_traffic_light(has_traffic_light), source_restricted(source_restricted),
+          target_restricted(target_restricted), is_left_hand_driving(is_left_hand_driving),
+          weight(0.), duration(0.), source_mode(source_mode), target_mode(target_mode)
    {
    }
+
    const double angle;
    const int number_of_roads;
    const bool is_u_turn;
    const bool has_traffic_light;
-    const bool is_left_hand_driving;
-
-    // source info
    const bool source_restricted;
-    const TravelMode source_mode;
-    const bool source_is_motorway;
-    const bool source_is_link;
-    const int source_number_of_lanes;
-    const int source_highway_turn_classification;
-    const int source_access_turn_classification;
-    const int source_speed;
-    const RoadPriorityClass::Enum source_priority_class;
-
-    // target info
    const bool target_restricted;
-    const TravelMode target_mode;
-    const bool target_is_motorway;
-    const bool target_is_link;
-    const int target_number_of_lanes;
-    const int target_highway_turn_classification;
-    const int target_access_turn_classification;
-    const int target_speed;
-    const RoadPriorityClass::Enum target_priority_class;
-
-    const std::vector<ExtractionTurnLeg> roads_on_the_right;
-    const std::vector<ExtractionTurnLeg> roads_on_the_left;
-
+    const bool is_left_hand_driving;
    double weight;
    double duration;
+    TravelMode source_mode;
+    TravelMode target_mode;
 };
 }
 }
@@ -1,7 +1,7 @@
 #ifndef EXTRACTION_WAY_HPP
 #define EXTRACTION_WAY_HPP

-#include "extractor/road_classification.hpp"
+#include "extractor/guidance/road_classification.hpp"
 #include "extractor/travel_mode.hpp"
 #include "util/guidance/turn_lanes.hpp"
 #include "util/typedefs.hpp"
@@ -54,17 +54,15 @@ struct ExtractionWay
        exits.clear();
        turn_lanes_forward.clear();
        turn_lanes_backward.clear();
-        road_classification = RoadClassification();
-        forward_travel_mode = TRAVEL_MODE_INACCESSIBLE;
-        backward_travel_mode = TRAVEL_MODE_INACCESSIBLE;
+        road_classification = guidance::RoadClassification();
+        forward_travel_mode = extractor::TRAVEL_MODE_INACCESSIBLE;
+        backward_travel_mode = extractor::TRAVEL_MODE_INACCESSIBLE;
        roundabout = false;
        circular = false;
        is_startpoint = true;
        forward_restricted = false;
        backward_restricted = false;
        is_left_hand_driving = false;
-        highway_turn_classification = 0;
-        access_turn_classification = 0;
    }

    // wrappers to allow assigning nil (nullptr) to string values
@@ -113,9 +111,9 @@ struct ExtractionWay
    std::string exits;
    std::string turn_lanes_forward;
    std::string turn_lanes_backward;
-    RoadClassification road_classification;
-    TravelMode forward_travel_mode : 4;
-    TravelMode backward_travel_mode : 4;
+    guidance::RoadClassification road_classification;
+    extractor::TravelMode forward_travel_mode : 4;
+    extractor::TravelMode backward_travel_mode : 4;

    // Boolean flags
    bool roundabout : 1;
@@ -125,10 +123,6 @@ struct ExtractionWay
    bool backward_restricted : 1;
    bool is_left_hand_driving : 1;
    bool : 2;
-
-    // user classifications for turn penalties
-    std::uint8_t highway_turn_classification : 4;
-    std::uint8_t access_turn_classification : 4;
 };
 }
 }
@@ -32,12 +32,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "extractor/edge_based_graph_factory.hpp"
 #include "extractor/extractor_config.hpp"
 #include "extractor/graph_compressor.hpp"
-#include "extractor/maneuver_override.hpp"
 #include "extractor/packed_osm_ids.hpp"

-#include "guidance/guidance_processing.hpp"
-#include "guidance/turn_data_container.hpp"
-
 #include "util/guidance/bearing_class.hpp"
 #include "util/guidance/entry_class.hpp"
 #include "util/guidance/turn_lanes.hpp"
@@ -61,10 +57,9 @@ class Extractor
  private:
    ExtractorConfig config;

-    std::tuple<LaneDescriptionMap,
+    std::tuple<guidance::LaneDescriptionMap,
               std::vector<TurnRestriction>,
-               std::vector<ConditionalTurnRestriction>,
-               std::vector<UnresolvedManeuverOverride>>
+               std::vector<ConditionalTurnRestriction>>
    ParseOSMData(ScriptingEnvironment &scripting_environment, const unsigned number_of_threads);

    EdgeID BuildEdgeExpandedGraph(
@@ -77,9 +72,8 @@ class Extractor
        const std::vector<TurnRestriction> &turn_restrictions,
        const std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
        const std::unordered_set<EdgeID> &segregated_edges,
-        const util::NameTable &name_table,
-        const std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
-        const LaneDescriptionMap &turn_lane_map,
+        // might have to be updated to add new lane combinations
+        guidance::LaneDescriptionMap &turn_lane_map,
        // for calculating turn penalties
        ScriptingEnvironment &scripting_environment,
        // output data
@@ -88,7 +82,7 @@ class Extractor
        std::vector<bool> &node_is_startpoint,
        std::vector<EdgeWeight> &edge_based_node_weights,
        util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
-        std::uint32_t &connectivity_checksum);
+        const std::string &intersection_class_output_file);

    void FindComponents(unsigned max_edge_id,
                        const util::DeallocatingVector<EdgeBasedEdge> &input_edge_list,
@@ -107,18 +101,6 @@ class Extractor
    void WriteConditionalRestrictions(
        const std::string &path,
        std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions);
-
-    void ProcessGuidanceTurns(
-        const util::NodeBasedDynamicGraph &node_based_graph,
-        const EdgeBasedNodeDataContainer &edge_based_node_container,
-        const std::vector<util::Coordinate> &node_coordinates,
-        const CompressedEdgeContainer &compressed_edge_container,
-        const std::unordered_set<NodeID> &barrier_nodes,
-        const std::vector<TurnRestriction> &turn_restrictions,
-        const std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
-        const util::NameTable &name_table,
-        LaneDescriptionMap lane_description_map,
-        ScriptingEnvironment &scripting_environment);
 };
 }
 }
@@ -2,7 +2,7 @@
 #define EXTRACTOR_CALLBACKS_HPP

 #include "extractor/class_data.hpp"
-#include "extractor/turn_lane_types.hpp"
+#include "extractor/guidance/turn_lane_types.hpp"
 #include "util/typedefs.hpp"

 #include <boost/functional/hash.hpp>
@@ -48,7 +48,6 @@ struct ExtractionWay;
 struct ExtractionRelation;
 struct ProfileProperties;
 struct InputConditionalTurnRestriction;
-struct InputManeuverOverride;

 /**
 * This class is used by the extractor with the results of the
@@ -68,7 +67,7 @@ class ExtractorCallbacks
    StringMap string_map;
    ExtractionContainers &external_memory;
    std::unordered_map<std::string, ClassData> &classes_map;
-    LaneDescriptionMap &lane_description_map;
+    guidance::LaneDescriptionMap &lane_description_map;
    bool fallback_to_duration;
    bool force_split_edges;

@@ -77,7 +76,7 @@ class ExtractorCallbacks

    explicit ExtractorCallbacks(ExtractionContainers &extraction_containers,
                                std::unordered_map<std::string, ClassData> &classes_map,
-                                LaneDescriptionMap &lane_description_map,
+                                guidance::LaneDescriptionMap &lane_description_map,
                                const ProfileProperties &properties);

    ExtractorCallbacks(const ExtractorCallbacks &) = delete;
@@ -91,9 +90,6 @@ class ExtractorCallbacks

    // warning: caller needs to take care of synchronization!
    void ProcessWay(const osmium::Way &current_way, const ExtractionWay &result_way);
-
-    // warning: caller needs to take care of synchronization!
-    void ProcessManeuverOverride(const InputManeuverOverride & override);
 };
 }
 }
@@ -67,8 +67,7 @@ struct ExtractorConfig final : storage::IOConfig
                                      ".osrm.properties",
                                      ".osrm.icd",
                                      ".osrm.cnbg",
-                                      ".osrm.cnbg_to_ebg",
-                                      ".osrm.maneuver_overrides"}),
+                                      ".osrm.cnbg_to_ebg"}),
                                 requested_num_threads(0),
                                 parse_conditionals(false),
                                 use_locations_cache(true)
@@ -2,10 +2,11 @@
 #define OSRM_EXTRACTOR_FILES_HPP

 #include "extractor/edge_based_edge.hpp"
+#include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/node_data_container.hpp"
 #include "extractor/profile_properties.hpp"
 #include "extractor/serialization.hpp"
-#include "extractor/turn_lane_types.hpp"
+#include "extractor/turn_data_container.hpp"

 #include "util/coordinate.hpp"
 #include "util/guidance/bearing_class.hpp"
@@ -78,8 +79,7 @@ inline void writeProfileProperties(const boost::filesystem::path &path,
 template <typename EdgeBasedEdgeVector>
 void writeEdgeBasedGraph(const boost::filesystem::path &path,
                         EdgeID const number_of_edge_based_nodes,
-                         const EdgeBasedEdgeVector &edge_based_edge_list,
-                         const std::uint32_t connectivity_checksum)
+                         const EdgeBasedEdgeVector &edge_based_edge_list)
 {
    static_assert(std::is_same<typename EdgeBasedEdgeVector::value_type, EdgeBasedEdge>::value, "");

@@ -87,14 +87,12 @@ void writeEdgeBasedGraph(const boost::filesystem::path &path,

    writer.WriteElementCount64(number_of_edge_based_nodes);
    storage::serialization::write(writer, edge_based_edge_list);
-    writer.WriteOne(connectivity_checksum);
 }

 template <typename EdgeBasedEdgeVector>
 void readEdgeBasedGraph(const boost::filesystem::path &path,
                        EdgeID &number_of_edge_based_nodes,
-                        EdgeBasedEdgeVector &edge_based_edge_list,
-                        std::uint32_t &connectivity_checksum)
+                        EdgeBasedEdgeVector &edge_based_edge_list)
 {
    static_assert(std::is_same<typename EdgeBasedEdgeVector::value_type, EdgeBasedEdge>::value, "");

@@ -102,7 +100,6 @@ void readEdgeBasedGraph(const boost::filesystem::path &path,

    number_of_edge_based_nodes = reader.ReadElementCount64();
    storage::serialization::read(reader, edge_based_edge_list);
-    reader.ReadInto(connectivity_checksum);
 }

 // reads .osrm.nodes
@@ -200,6 +197,34 @@ inline void writeSegmentData(const boost::filesystem::path &path, const SegmentD
    serialization::write(writer, segment_data);
 }

+// reads .osrm.edges
+template <typename TurnDataT>
+inline void readTurnData(const boost::filesystem::path &path, TurnDataT &turn_data)
+{
+    static_assert(std::is_same<TurnDataContainer, TurnDataT>::value ||
+                      std::is_same<TurnDataView, TurnDataT>::value ||
+                      std::is_same<TurnDataExternalContainer, TurnDataT>::value,
+                  "");
+    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    serialization::read(reader, turn_data);
+}
+
+// writes .osrm.edges
+template <typename TurnDataT>
+inline void writeTurnData(const boost::filesystem::path &path, const TurnDataT &turn_data)
+{
+    static_assert(std::is_same<TurnDataContainer, TurnDataT>::value ||
+                      std::is_same<TurnDataView, TurnDataT>::value ||
+                      std::is_same<TurnDataExternalContainer, TurnDataT>::value,
+                  "");
+    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    serialization::write(writer, turn_data);
+}
+
 // reads .osrm.ebg_nodes
 template <typename NodeDataT>
 inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_data)
@@ -234,8 +259,9 @@ inline void readTurnLaneDescriptions(const boost::filesystem::path &path,
                                     OffsetsT &turn_offsets,
                                     MaskT &turn_masks)
 {
-    static_assert(std::is_same<typename MaskT::value_type, extractor::TurnLaneType::Mask>::value,
-                  "");
+    static_assert(
+        std::is_same<typename MaskT::value_type, extractor::guidance::TurnLaneType::Mask>::value,
+        "");
    static_assert(std::is_same<typename OffsetsT::value_type, std::uint32_t>::value, "");

    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
@@ -251,8 +277,9 @@ inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
                                      const OffsetsT &turn_offsets,
                                      const MaskT &turn_masks)
 {
-    static_assert(std::is_same<typename MaskT::value_type, extractor::TurnLaneType::Mask>::value,
-                  "");
+    static_assert(
+        std::is_same<typename MaskT::value_type, extractor::guidance::TurnLaneType::Mask>::value,
+        "");
    static_assert(std::is_same<typename OffsetsT::value_type, std::uint32_t>::value, "");

    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
@@ -261,29 +288,6 @@ inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
    storage::serialization::write(writer, turn_offsets);
    storage::serialization::write(writer, turn_masks);
 }
-
-// reads .osrm.maneuver_overrides
-template <typename StorageManeuverOverrideT, typename NodeSequencesT>
-inline void readManeuverOverrides(const boost::filesystem::path &path,
-                                  StorageManeuverOverrideT &maneuver_overrides,
-                                  NodeSequencesT &node_sequences)
-{
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    serialization::read(reader, maneuver_overrides, node_sequences);
-}
-
-// writes .osrm.maneuver_overrides
-inline void writeManeuverOverrides(const boost::filesystem::path &path,
-                                   const std::vector<StorageManeuverOverride> &maneuver_overrides,
-                                   const std::vector<NodeID> &node_sequences)
-{
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    serialization::write(writer, maneuver_overrides, node_sequences);
-}
 }
 }
 }
@@ -10,8 +10,8 @@
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"

-#include "guidance/coordinate_extractor.hpp"
-#include "guidance/intersection.hpp"
+#include "extractor/guidance/coordinate_extractor.hpp"
+#include "extractor/guidance/intersection.hpp"
 #include "util/coordinate.hpp"
 #include "util/geojson_debug_policy_toolkit.hpp"

@@ -4,7 +4,6 @@
 #include "extractor/scripting_environment.hpp"
 #include "util/typedefs.hpp"

-#include "extractor/maneuver_override.hpp"
 #include "util/node_based_graph.hpp"

 #include <memory>
@@ -29,7 +28,6 @@ class GraphCompressor
                  ScriptingEnvironment &scripting_environment,
                  std::vector<TurnRestriction> &turn_restrictions,
                  std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
-                  std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
                  util::NodeBasedDynamicGraph &graph,
                  const std::vector<NodeBasedEdgeAnnotation> &node_data_container,
                  CompressedEdgeContainer &geometry_compressor);
@@ -1,13 +1,15 @@
-#ifndef OSRM_EXTRACTOR_INTERSECTION_CONSTANTS_HPP_
-#define OSRM_EXTRACTOR_INTERSECTION_CONSTANTS_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_CONSTANTS_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_CONSTANTS_HPP_

 namespace osrm
 {
 namespace extractor
 {
-namespace intersection
+namespace guidance
 {

+const bool constexpr INVERT = true;
+
 // what angle is interpreted as going straight
 const double constexpr STRAIGHT_ANGLE = 180.;
 const double constexpr ORTHOGONAL_ANGLE = 90.;
@@ -18,6 +20,17 @@ const double constexpr NARROW_TURN_ANGLE = 40.;
 const double constexpr GROUP_ANGLE = 60;
 // angle difference that can be classified as straight, if its the only narrow turn
 const double constexpr FUZZY_ANGLE_DIFFERENCE = 25.;
+const double constexpr DISTINCTION_RATIO = 2;
+
+// Named roundabouts with radii larger then than this are seen as rotary
+const double constexpr MAX_ROUNDABOUT_RADIUS = 15;
+// Unnamed small roundabouts that look like intersections are announced as turns,
+// guard against data issues or such roundabout intersections getting too large.
+const double constexpr MAX_ROUNDABOUT_INTERSECTION_RADIUS = 15;
+
+const double constexpr INCREASES_BY_FOURTY_PERCENT = 1.4;
+
+const int constexpr MAX_SLIPROAD_THRESHOLD = 250;

 // Road priorities give an idea of how obvious a turn is. If two priorities differ greatly (e.g.
 // service road over a primary road, the better priority can be seen as obvious due to its road
@@ -30,8 +43,8 @@ const auto constexpr ASSUMED_LANE_WIDTH = 3.25;
 // how far apart can roads be at the most, when thinking about merging them?
 const auto constexpr MERGABLE_ANGLE_DIFFERENCE = 95.0;

-} // namespace intersection
+} // namespace guidance
 } // namespace extractor
 } // namespace osrm

-#endif // OSRM_EXTRACTOR_INTERSECTION_CONSTANTS_HPP_
+#endif // OSRM_EXTRACTOR_GUIDANCE_CONSTANTS_HPP_
@@ -1,5 +1,5 @@
-#ifndef OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_
-#define OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_
+#ifndef OSRM_EXTRACTOR_COORDINATE_EXTRACTOR_HPP_
+#define OSRM_EXTRACTOR_COORDINATE_EXTRACTOR_HPP_

 #include <utility>
 #include <vector>
@@ -15,7 +15,7 @@ namespace osrm
 {
 namespace extractor
 {
-namespace intersection
+namespace guidance
 {

 class CoordinateExtractor
@@ -251,8 +251,8 @@ class CoordinateExtractor
                        const std::uint8_t considered_lanes) const;
 };

-} // namespace intersection
+} // namespace guidance
 } // namespace extractor
 } // namespace osrm

-#endif // OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_
+#endif // OSRM_EXTRACTOR_COORDINATE_EXTRACTOR_HPP_
@@ -1,10 +1,12 @@
-#ifndef OSRM_GUIDANCE_DRIVEWAY_HANDLER_HPP
-#define OSRM_GUIDANCE_DRIVEWAY_HANDLER_HPP
+#ifndef OSRM_EXTRACTOR_GUIDANCE_DRIVEWAY_HANDLER_HPP
+#define OSRM_EXTRACTOR_GUIDANCE_DRIVEWAY_HANDLER_HPP

-#include "guidance/intersection_handler.hpp"
+#include "extractor/guidance/intersection_handler.hpp"

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -13,14 +15,14 @@ class DrivewayHandler final : public IntersectionHandler
 {
  public:
    DrivewayHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                    const extractor::EdgeBasedNodeDataContainer &node_data_container,
+                    const EdgeBasedNodeDataContainer &node_data_container,
                    const std::vector<util::Coordinate> &coordinates,
                    const extractor::CompressedEdgeContainer &compressed_geometries,
-                    const extractor::RestrictionMap &node_restriction_map,
+                    const RestrictionMap &node_restriction_map,
                    const std::unordered_set<NodeID> &barrier_nodes,
-                    const extractor::TurnLanesIndexedArray &turn_lanes_data,
+                    const guidance::TurnLanesIndexedArray &turn_lanes_data,
                    const util::NameTable &name_table,
-                    const extractor::SuffixTable &street_name_suffix_table);
+                    const SuffixTable &street_name_suffix_table);

    ~DrivewayHandler() override final = default;

@@ -36,6 +38,7 @@ class DrivewayHandler final : public IntersectionHandler
 };

 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

-#endif /* OSRM_GUIDANCE_DRIVEWAY_HANDLER_HPP */
+#endif /* OSRM_EXTRACTOR_GUIDANCE_DRIVEWAY_HANDLER_HPP */
@@ -1,5 +1,5 @@
-#ifndef OSRM_EXTRACTOR_INTERSECTION_INTERSECTION_VIEW_HPP_
-#define OSRM_EXTRACTOR_INTERSECTION_INTERSECTION_VIEW_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_INTERSECTION_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_INTERSECTION_HPP_

 #include <algorithm>
 #include <functional>
@@ -13,7 +13,7 @@
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp" // EdgeID

-#include "guidance/turn_instruction.hpp"
+#include "extractor/guidance/turn_instruction.hpp"

 #include <boost/range/algorithm/count_if.hpp>
 #include <boost/range/algorithm/find_if.hpp>
@@ -23,7 +23,7 @@ namespace osrm
 {
 namespace extractor
 {
-namespace intersection
+namespace guidance
 {

 // the shape of an intersection only knows about edge IDs and bearings
@@ -44,6 +44,14 @@ inline auto makeCompareShapeDataByBearing(const double base_bearing)
    };
 }

+inline auto makeCompareShapeDataAngleToBearing(const double base_bearing)
+{
+    return [base_bearing](const auto &lhs, const auto &rhs) {
+        return util::bearing::angleBetween(lhs.bearing, base_bearing) <
+               util::bearing::angleBetween(rhs.bearing, base_bearing);
+    };
+}
+
 inline auto makeCompareAngularDeviation(const double angle)
 {
    return [angle](const auto &lhs, const auto &rhs) {
@@ -75,6 +83,53 @@ struct IntersectionViewData : IntersectionShapeData
    bool CompareByAngle(const IntersectionViewData &other) const;
 };

+// A Connected Road is the internal representation of a potential turn. Internally, we require
+// full list of all connected roads to determine the outcome.
+// The reasoning behind is that even invalid turns can influence the perceived angles, or even
+// instructions themselves. An possible example can be described like this:
+//
+// aaa(2)aa
+//          a - bbbbb
+// aaa(1)aa
+//
+// will not be perceived as a turn from (1) -> b, and as a U-turn from (1) -> (2).
+// In addition, they can influence whether a turn is obvious or not. b->(2) would also be no
+// turn-operation, but rather a name change.
+//
+// If this were a normal intersection with
+//
+// cccccccc
+//            o  bbbbb
+// aaaaaaaa
+//
+// We would perceive a->c as a sharp turn, a->b as a slight turn, and b->c as a slight turn.
+struct ConnectedRoad final : IntersectionViewData
+{
+    ConnectedRoad(const IntersectionViewData &view,
+                  const TurnInstruction instruction,
+                  const LaneDataID lane_data_id)
+        : IntersectionViewData(view), instruction(instruction), lane_data_id(lane_data_id)
+    {
+    }
+
+    TurnInstruction instruction;
+    LaneDataID lane_data_id;
+
+    // used to sort the set of connected roads (we require sorting throughout turn handling)
+    bool compareByAngle(const ConnectedRoad &other) const;
+
+    // make a left turn into an equivalent right turn and vice versa
+    void mirror();
+
+    OSRM_ATTR_WARN_UNUSED
+    ConnectedRoad getMirroredCopy() const;
+};
+
+// small helper function to print the content of a connected road
+std::string toString(const IntersectionShapeData &shape);
+std::string toString(const IntersectionViewData &view);
+std::string toString(const ConnectedRoad &road);
+
 // Intersections are sorted roads: [0] being the UTurn road, then from sharp right to sharp left.
 // common operations shared amongst all intersection types
 template <typename Self> struct EnableShapeOps
@@ -245,8 +300,39 @@ struct IntersectionView final : std::vector<IntersectionViewData>,      //
    using Base = std::vector<IntersectionViewData>;
 };

-} // namespace intersection
+// `Intersection` is a relative view of an intersection by an incoming edge.
+// `Intersection` are streets at an intersection ordered from from sharp right counter-clockwise to
+// sharp left where `intersection[0]` is _always_ a u-turn
+
+// An intersection is an ordered list of connected roads ordered from from sharp right
+// counter-clockwise to sharp left where `intersection[0]` is always a u-turn
+//
+//                                           |
+//                                           |
+//                                     (intersec[3])
+//                                           |
+//                                           |
+//                                           |
+//  nid ---(via_eid/intersec[0])--- nbg.GetTarget(via)  ---(intersec[2])---
+//                                           |
+//                                           |
+//                                           |
+//                                     (intersec[1])
+//                                           |
+//                                           |
+//
+// intersec := intersection
+// nbh := node_based_graph
+//
+struct Intersection final : std::vector<ConnectedRoad>,         //
+                            EnableShapeOps<Intersection>,       //
+                            EnableIntersectionOps<Intersection> //
+{
+    using Base = std::vector<ConnectedRoad>;
+};
+
+} // namespace guidance
 } // namespace extractor
 } // namespace osrm

-#endif /* OSRM_EXTRACTOR_INTERSECTION_INTERSECTION_VIEW_HPP_*/
+#endif /*OSRM_EXTRACTOR_GUIDANCE_INTERSECTION_HPP_*/
@@ -1,11 +1,11 @@
-#ifndef OSRM_GUIDANCE_INTERSECTION_HANDLER_HPP_
-#define OSRM_GUIDANCE_INTERSECTION_HANDLER_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_INTERSECTION_HANDLER_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_INTERSECTION_HANDLER_HPP_

+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/node_based_graph_walker.hpp"
 #include "extractor/intersection/intersection_analysis.hpp"
-#include "extractor/intersection/node_based_graph_walker.hpp"
+#include "extractor/query_node.hpp"
 #include "extractor/suffix_table.hpp"
-#include "guidance/constants.hpp"
-#include "guidance/intersection.hpp"

 #include "util/coordinate_calculation.hpp"
 #include "util/guidance/name_announcements.hpp"
@@ -21,6 +21,8 @@

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -31,14 +33,14 @@ class IntersectionHandler
 {
  public:
    IntersectionHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                        const extractor::EdgeBasedNodeDataContainer &node_data_container,
+                        const EdgeBasedNodeDataContainer &node_data_container,
                        const std::vector<util::Coordinate> &node_coordinates,
                        const extractor::CompressedEdgeContainer &compressed_geometries,
-                        const extractor::RestrictionMap &node_restriction_map,
+                        const RestrictionMap &node_restriction_map,
                        const std::unordered_set<NodeID> &barrier_nodes,
-                        const extractor::TurnLanesIndexedArray &turn_lanes_data,
+                        const guidance::TurnLanesIndexedArray &turn_lanes_data,
                        const util::NameTable &name_table,
-                        const extractor::SuffixTable &street_name_suffix_table);
+                        const SuffixTable &street_name_suffix_table);

    virtual ~IntersectionHandler() = default;

@@ -52,22 +54,19 @@ class IntersectionHandler

  protected:
    const util::NodeBasedDynamicGraph &node_based_graph;
-    const extractor::EdgeBasedNodeDataContainer &node_data_container;
+    const EdgeBasedNodeDataContainer &node_data_container;
    const std::vector<util::Coordinate> &node_coordinates;
    const extractor::CompressedEdgeContainer &compressed_geometries;
-    const extractor::RestrictionMap &node_restriction_map;
+    const RestrictionMap &node_restriction_map;
    const std::unordered_set<NodeID> &barrier_nodes;
-    const extractor::TurnLanesIndexedArray &turn_lanes_data;
+    const guidance::TurnLanesIndexedArray &turn_lanes_data;
    const util::NameTable &name_table;
-    const extractor::SuffixTable &street_name_suffix_table;
-    const extractor::intersection::NodeBasedGraphWalker
-        graph_walker; // for skipping traffic signal, distances etc.
+    const SuffixTable &street_name_suffix_table;
+    const NodeBasedGraphWalker graph_walker; // for skipping traffic signal, distances etc.

    // Decide on a basic turn types
    TurnType::Enum findBasicTurnType(const EdgeID via_edge, const ConnectedRoad &candidate) const;

-    TurnType::Enum areSameClasses(const EdgeID via_edge, const ConnectedRoad &road) const;
-
    // Find the most obvious turn to follow. The function returns an index into the intersection
    // determining whether there is a road that can be seen as obvious turn in the presence of many
    // other possible turns. The function will consider road categories and other inputs like the
@@ -97,11 +96,14 @@ class IntersectionHandler
                            const std::size_t begin,
                            const std::size_t end) const;

+    // Checks the intersection for a through street connected to `intersection[index]`
+    bool isThroughStreet(const std::size_t index, const Intersection &intersection) const;
+
    // See `getNextIntersection`
    struct IntersectionViewAndNode final
    {
-        extractor::intersection::IntersectionView intersection; // < actual intersection
-        NodeID node;                                            // < node at this intersection
+        IntersectionView intersection; // < actual intersection
+        NodeID node;                   // < node at this intersection
    };

    // Skips over artificial intersections i.e. traffic lights, barriers etc.
@@ -152,7 +154,7 @@ std::size_t IntersectionHandler::findObviousTurn(const EdgeID via_edge,
    double best_continue_deviation = 180;

    /* helper functions */
-    const auto IsContinueRoad = [&](const extractor::NodeBasedEdgeAnnotation &way_data) {
+    const auto IsContinueRoad = [&](const NodeBasedEdgeAnnotation &way_data) {
        return !util::guidance::requiresNameAnnounced(
            in_way_data.name_id, way_data.name_id, name_table, street_name_suffix_table);
    };
@@ -570,20 +572,20 @@ std::size_t IntersectionHandler::findObviousTurn(const EdgeID via_edge,
            // even reverse the direction. Since we don't want to compute actual turns but simply
            // try to find whether there is a turn going to the opposite direction of our obvious
            // turn, this should be alright.
-            const auto previous_intersection = [&]() -> extractor::intersection::IntersectionView {
-                const auto parameters = extractor::intersection::skipDegreeTwoNodes(
+            const auto previous_intersection = [&]() -> IntersectionView {
+                const auto parameters = intersection::skipDegreeTwoNodes(
                    node_based_graph, {node_at_intersection, intersection[0].eid});
                if (node_based_graph.GetTarget(parameters.edge) == node_at_intersection)
                    return {};

-                return extractor::intersection::getConnectedRoads<false>(node_based_graph,
-                                                                         node_data_container,
-                                                                         node_coordinates,
-                                                                         compressed_geometries,
-                                                                         node_restriction_map,
-                                                                         barrier_nodes,
-                                                                         turn_lanes_data,
-                                                                         parameters);
+                return intersection::getConnectedRoads<false>(node_based_graph,
+                                                              node_data_container,
+                                                              node_coordinates,
+                                                              compressed_geometries,
+                                                              node_restriction_map,
+                                                              barrier_nodes,
+                                                              turn_lanes_data,
+                                                              parameters);
            }();

            if (!previous_intersection.empty())
@@ -614,6 +616,7 @@ std::size_t IntersectionHandler::findObviousTurn(const EdgeID via_edge,
 }

 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

-#endif /*OSRM_GUIDANCE_INTERSECTION_HANDLER_HPP_*/
+#endif /*OSRM_EXTRACTOR_GUIDANCE_INTERSECTION_HANDLER_HPP_*/
@@ -2,11 +2,10 @@
 #define OSRM_EXTRACTOR_GUIDANCE_MERGEABLE_ROADS

 #include "extractor/compressed_edge_container.hpp"
-#include "extractor/intersection/coordinate_extractor.hpp"
-#include "extractor/intersection/have_identical_names.hpp"
+#include "extractor/guidance/coordinate_extractor.hpp"
+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/restriction_index.hpp"
-#include "extractor/turn_lane_types.hpp"
-#include "guidance/intersection.hpp"
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"
@@ -31,7 +30,7 @@ namespace extractor

 class SuffixTable;

-namespace intersection
+namespace guidance
 {
 class IntersectionGenerator;
 class CoordinateExtractor;
@@ -48,7 +47,7 @@ class MergableRoadDetector
                         const extractor::CompressedEdgeContainer &compressed_geometries,
                         const RestrictionMap &node_restriction_map,
                         const std::unordered_set<NodeID> &barrier_nodes,
-                         const TurnLanesIndexedArray &turn_lanes_data,
+                         const guidance::TurnLanesIndexedArray &turn_lanes_data,
                         const util::NameTable &name_table,
                         const SuffixTable &street_name_suffix_table);

@@ -79,6 +78,11 @@ class MergableRoadDetector
    bool IsDistinctFrom(const MergableRoadData &lhs, const MergableRoadData &rhs) const;

  private:
+    // check if two name ids can be seen as identical (in presence of refs/others)
+    // in our case this translates into no name announcement in either direction (lhs->rhs and
+    // rhs->lhs)
+    bool HaveIdenticalNames(const NameID lhs, const NameID rhs) const;
+
    // When it comes to merging roads, we need to find out if two ways actually represent the
    // same road. This check tries to identify roads which are the same road in opposite directions
    bool EdgeDataSupportsMerge(const NodeBasedEdgeClassification &lhs_flags,
@@ -165,7 +169,7 @@ class MergableRoadDetector
    const extractor::CompressedEdgeContainer &compressed_geometries;
    const RestrictionMap &node_restriction_map;
    const std::unordered_set<NodeID> &barrier_nodes;
-    const TurnLanesIndexedArray &turn_lanes_data;
+    const guidance::TurnLanesIndexedArray &turn_lanes_data;

    // name detection
    const util::NameTable &name_table;
@@ -177,7 +181,7 @@ class MergableRoadDetector
    const static double constexpr distance_to_extract = 120;
 };

-} // namespace intersection
+} // namespace guidance
 } // namespace extractor
 } // namespace osrm

@@ -1,9 +1,9 @@
-#ifndef OSRM_GUIDANCE_MOTORWAY_HANDLER_HPP_
-#define OSRM_GUIDANCE_MOTORWAY_HANDLER_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_MOTORWAY_HANDLER_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_MOTORWAY_HANDLER_HPP_

-#include "guidance/intersection.hpp"
-#include "guidance/intersection_handler.hpp"
-#include "guidance/is_through_street.hpp"
+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/intersection_handler.hpp"
+#include "extractor/query_node.hpp"

 #include "util/attributes.hpp"
 #include "util/name_table.hpp"
@@ -13,6 +13,8 @@

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -21,14 +23,14 @@ class MotorwayHandler : public IntersectionHandler
 {
  public:
    MotorwayHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                    const extractor::EdgeBasedNodeDataContainer &node_data_container,
+                    const EdgeBasedNodeDataContainer &node_data_container,
                    const std::vector<util::Coordinate> &coordinates,
                    const extractor::CompressedEdgeContainer &compressed_geometries,
-                    const extractor::RestrictionMap &node_restriction_map,
+                    const RestrictionMap &node_restriction_map,
                    const std::unordered_set<NodeID> &barrier_nodes,
-                    const extractor::TurnLanesIndexedArray &turn_lanes_data,
+                    const guidance::TurnLanesIndexedArray &turn_lanes_data,
                    const util::NameTable &name_table,
-                    const extractor::SuffixTable &street_name_suffix_table);
+                    const SuffixTable &street_name_suffix_table);

    ~MotorwayHandler() override final = default;

@@ -58,6 +60,7 @@ class MotorwayHandler : public IntersectionHandler
 };

 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

-#endif /*OSRM_GUIDANCE_MOTORWAY_HANDLER_HPP_*/
+#endif /*OSRM_EXTRACTOR_GUIDANCE_MOTORWAY_HANDLER_HPP_*/
@@ -1,10 +1,10 @@
-#ifndef OSRM_EXTRACTOR_INTERSECTION_NODE_BASED_GRAPH_WALKER
-#define OSRM_EXTRACTOR_INTERSECTION_NODE_BASED_GRAPH_WALKER
+#ifndef OSRM_EXTRACTOR_GUIDANCE_NODE_BASED_GRAPH_WALKER
+#define OSRM_EXTRACTOR_GUIDANCE_NODE_BASED_GRAPH_WALKER

-#include "extractor/intersection/coordinate_extractor.hpp"
+#include "extractor/guidance/constants.hpp"
+#include "extractor/guidance/coordinate_extractor.hpp"
+#include "extractor/guidance/turn_lane_data.hpp"
 #include "extractor/intersection/intersection_analysis.hpp"
-#include "extractor/intersection/intersection_view.hpp"
-#include "guidance/turn_lane_data.hpp"
 #include "util/coordinate.hpp"
 #include "util/coordinate_calculation.hpp"
 #include "util/node_based_graph.hpp"
@@ -19,7 +19,7 @@ namespace osrm
 {
 namespace extractor
 {
-namespace intersection
+namespace guidance
 {

 /*
@@ -35,7 +35,7 @@ class NodeBasedGraphWalker
                         const extractor::CompressedEdgeContainer &compressed_geometries,
                         const RestrictionMap &node_restriction_map,
                         const std::unordered_set<NodeID> &barrier_nodes,
-                         const TurnLanesIndexedArray &turn_lanes_data);
+                         const guidance::TurnLanesIndexedArray &turn_lanes_data);

    /*
     * the returned node-id, edge-id are either the last ones used, just prior accumulator
@@ -58,7 +58,7 @@ class NodeBasedGraphWalker
    const extractor::CompressedEdgeContainer &compressed_geometries;
    const RestrictionMap &node_restriction_map;
    const std::unordered_set<NodeID> &barrier_nodes;
-    const TurnLanesIndexedArray &turn_lanes_data;
+    const guidance::TurnLanesIndexedArray &turn_lanes_data;
 };

 /*
@@ -68,7 +68,7 @@ class NodeBasedGraphWalker
 struct LengthLimitedCoordinateAccumulator
 {
    LengthLimitedCoordinateAccumulator(
-        const extractor::intersection::CoordinateExtractor &coordinate_extractor,
+        const extractor::guidance::CoordinateExtractor &coordinate_extractor,
        const double max_length);

    /*
@@ -93,7 +93,7 @@ struct LengthLimitedCoordinateAccumulator
    std::vector<util::Coordinate> coordinates;

  private:
-    const extractor::intersection::CoordinateExtractor &coordinate_extractor;
+    const extractor::guidance::CoordinateExtractor &coordinate_extractor;
    const double max_length;
 };

@@ -165,7 +165,7 @@ struct IntersectionFinderAccumulator
                                  const extractor::CompressedEdgeContainer &compressed_geometries,
                                  const RestrictionMap &node_restriction_map,
                                  const std::unordered_set<NodeID> &barrier_nodes,
-                                  const TurnLanesIndexedArray &turn_lanes_data);
+                                  const guidance::TurnLanesIndexedArray &turn_lanes_data);
    // true if the path has traversed enough distance
    bool terminate();

@@ -187,7 +187,7 @@ struct IntersectionFinderAccumulator
    const extractor::CompressedEdgeContainer &compressed_geometries;
    const RestrictionMap &node_restriction_map;
    const std::unordered_set<NodeID> &barrier_nodes;
-    const TurnLanesIndexedArray &turn_lanes_data;
+    const guidance::TurnLanesIndexedArray &turn_lanes_data;
 };

 template <class accumulator_type, class selector_type>
@@ -278,7 +278,7 @@ struct SkipTrafficSignalBarrierRoadSelector
 struct DistanceToNextIntersectionAccumulator
 {
    DistanceToNextIntersectionAccumulator(
-        const extractor::intersection::CoordinateExtractor &extractor_,
+        const extractor::guidance::CoordinateExtractor &extractor_,
        const util::NodeBasedDynamicGraph &graph_,
        const double threshold)
        : extractor{extractor_}, graph{graph_}, threshold{threshold}
@@ -304,15 +304,15 @@ struct DistanceToNextIntersectionAccumulator
        distance += getLength(coords.begin(), coords.end(), &haversineDistance);
    }

-    const extractor::intersection::CoordinateExtractor &extractor;
+    const extractor::guidance::CoordinateExtractor &extractor;
    const util::NodeBasedDynamicGraph &graph;
    const double threshold;
    bool too_far_away = false;
    double distance = 0.;
 };

-} // namespace intersection
+} // namespace guidance
 } // namespace extractor
 } // namespace osrm

-#endif
+#endif /* OSRM_EXTRACTOR_GUIDANCE_NODE_BASED_GRAPH_WALKER */
@@ -6,12 +6,14 @@
 #include <cstdlib>
 #include <string>

-#include "extractor/intersection/constants.hpp"
+#include "extractor/guidance/constants.hpp"

 namespace osrm
 {
 namespace extractor
 {
+namespace guidance
+{

 // Priorities are used to distinguish between how likely a turn is in comparison to a different
 // road. The priorities here are used to distinguish between obvious turns (e.g. following a primary
@@ -130,9 +132,8 @@ inline bool obviousByRoadClass(const RoadClassification in_classification,
                               const RoadClassification compare_candidate)
 {
    // lower numbers are of higher priority
-    const bool has_high_priority =
-        intersection::PRIORITY_DISTINCTION_FACTOR * obvious_candidate.GetPriority() <
-        compare_candidate.GetPriority();
+    const bool has_high_priority = PRIORITY_DISTINCTION_FACTOR * obvious_candidate.GetPriority() <
+                                   compare_candidate.GetPriority();

    const bool continues_on_same_class = in_classification == obvious_candidate;
    return (has_high_priority && continues_on_same_class) ||
@@ -141,6 +142,7 @@ inline bool obviousByRoadClass(const RoadClassification in_classification,
            compare_candidate.IsLowPriorityRoadClass());
 }

+} // namespace guidance
 } // namespace extractor
 } // namespace osrm

@@ -1,13 +1,12 @@
-#ifndef OSRM_GUIDANCE_ROUNDABOUT_HANDLER_HPP_
-#define OSRM_GUIDANCE_ROUNDABOUT_HANDLER_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_ROUNDABOUT_HANDLER_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_ROUNDABOUT_HANDLER_HPP_

 #include "extractor/compressed_edge_container.hpp"
-#include "extractor/intersection/coordinate_extractor.hpp"
+#include "extractor/guidance/coordinate_extractor.hpp"
+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/intersection_handler.hpp"
+#include "extractor/guidance/roundabout_type.hpp"
 #include "extractor/query_node.hpp"
-#include "guidance/intersection.hpp"
-#include "guidance/intersection_handler.hpp"
-#include "guidance/is_through_street.hpp"
-#include "guidance/roundabout_type.hpp"

 #include "util/name_table.hpp"
 #include "util/node_based_graph.hpp"
@@ -18,6 +17,8 @@

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -38,14 +39,14 @@ class RoundaboutHandler : public IntersectionHandler
 {
  public:
    RoundaboutHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                      const extractor::EdgeBasedNodeDataContainer &node_data_container,
+                      const EdgeBasedNodeDataContainer &node_data_container,
                      const std::vector<util::Coordinate> &coordinates,
                      const extractor::CompressedEdgeContainer &compressed_geometries,
-                      const extractor::RestrictionMap &node_restriction_map,
+                      const RestrictionMap &node_restriction_map,
                      const std::unordered_set<NodeID> &barrier_nodes,
-                      const extractor::TurnLanesIndexedArray &turn_lanes_data,
+                      const guidance::TurnLanesIndexedArray &turn_lanes_data,
                      const util::NameTable &name_table,
-                      const extractor::SuffixTable &street_name_suffix_table);
+                      const SuffixTable &street_name_suffix_table);

    ~RoundaboutHandler() override final = default;

@@ -80,10 +81,11 @@ class RoundaboutHandler : public IntersectionHandler
    bool
    qualifiesAsRoundaboutIntersection(const std::unordered_set<NodeID> &roundabout_nodes) const;

-    const extractor::intersection::CoordinateExtractor coordinate_extractor;
+    const CoordinateExtractor coordinate_extractor;
 };

 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

-#endif /*OSRM_GUIDANCE_ROUNDABOUT_HANDLER_HPP_*/
+#endif /*OSRM_EXTRACTOR_GUIDANCE_ROUNDABOUT_HANDLER_HPP_*/
@@ -1,8 +1,10 @@
-#ifndef OSRM_GUIDANCE_ROUNDABOUT_TYPES_HPP_
-#define OSRM_GUIDANCE_ROUNDABOUT_TYPES_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_ROUNDABOUT_TYPES_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_ROUNDABOUT_TYPES_HPP_

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {
 enum class RoundaboutType
@@ -13,6 +15,7 @@ enum class RoundaboutType
    RoundaboutIntersection // small roundabout with distinct turns, handled as intersection
 };
 } /* namespace guidance */
+} /* namespace extractor */
 } /* namespace osrm */

 #endif /* OSRM_EXTRACTOR_GUIDANCE_ROUNDABOUT_TYPES_HPP_ */
@@ -12,7 +12,6 @@ class NameTable;
 namespace extractor
 {
 class NodeBasedGraphFactory;
-}

 namespace guidance
 {
@@ -21,7 +20,8 @@ namespace guidance
 // - middle edges between two osm ways in one logic road (U-turn)
 // - staggered intersections (X-cross)
 // - square/circle intersections
-std::unordered_set<EdgeID> findSegregatedNodes(const extractor::NodeBasedGraphFactory &factory,
+std::unordered_set<EdgeID> findSegregatedNodes(const NodeBasedGraphFactory &factory,
                                               const util::NameTable &names);
 }
 }
+}
@@ -1,9 +1,9 @@
-#ifndef OSRM_GUIDANCE_SLIPROAD_HANDLER_HPP_
-#define OSRM_GUIDANCE_SLIPROAD_HANDLER_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_SLIPROAD_HANDLER_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_SLIPROAD_HANDLER_HPP_

-#include "guidance/intersection.hpp"
-#include "guidance/intersection_handler.hpp"
-#include "guidance/is_through_street.hpp"
+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/intersection_handler.hpp"
+#include "extractor/query_node.hpp"

 #include "util/name_table.hpp"
 #include "util/node_based_graph.hpp"
@@ -14,6 +14,8 @@

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -22,14 +24,14 @@ class SliproadHandler final : public IntersectionHandler
 {
  public:
    SliproadHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                    const extractor::EdgeBasedNodeDataContainer &node_data_container,
+                    const EdgeBasedNodeDataContainer &node_data_container,
                    const std::vector<util::Coordinate> &coordinates,
                    const extractor::CompressedEdgeContainer &compressed_geometries,
-                    const extractor::RestrictionMap &node_restriction_map,
+                    const RestrictionMap &node_restriction_map,
                    const std::unordered_set<NodeID> &barrier_nodes,
-                    const extractor::TurnLanesIndexedArray &turn_lanes_data,
+                    const guidance::TurnLanesIndexedArray &turn_lanes_data,
                    const util::NameTable &name_table,
-                    const extractor::SuffixTable &street_name_suffix_table);
+                    const SuffixTable &street_name_suffix_table);

    ~SliproadHandler() override final = default;

@@ -51,6 +53,9 @@ class SliproadHandler final : public IntersectionHandler
    // Next intersection from `start` onto `onto` is too far away for a Siproad scenario
    bool nextIntersectionIsTooFarAway(const NodeID start, const EdgeID onto) const;

+    // Through street: does a road continue with from's name at the intersection
+    bool isThroughStreet(const EdgeID from, const IntersectionView &intersection) const;
+
    // Does the road from `current` to `next` continue
    bool roadContinues(const EdgeID current, const EdgeID next) const;

@@ -58,9 +63,9 @@ class SliproadHandler final : public IntersectionHandler
    bool isValidSliproadArea(const double max_area, const NodeID, const NodeID, const NodeID) const;

    // Is the Sliproad a link the both roads it shortcuts must not be links
-    bool isValidSliproadLink(const extractor::intersection::IntersectionViewData &sliproad,
-                             const extractor::intersection::IntersectionViewData &first,
-                             const extractor::intersection::IntersectionViewData &second) const;
+    bool isValidSliproadLink(const IntersectionViewData &sliproad,
+                             const IntersectionViewData &first,
+                             const IntersectionViewData &second) const;

    // check if no mode changes are involved
    bool allSameMode(const EdgeID in_road,
@@ -68,19 +73,19 @@ class SliproadHandler final : public IntersectionHandler
                     const EdgeID target_road) const;

    // Could a Sliproad reach this intersection?
-    static bool
-    canBeTargetOfSliproad(const extractor::intersection::IntersectionView &intersection);
+    static bool canBeTargetOfSliproad(const IntersectionView &intersection);

    // Scales a threshold based on the underlying road classification.
    // Example: a 100 m threshold for a highway if different on living streets.
    // The return value is guaranteed to not be larger than `threshold`.
    static double scaledThresholdByRoadClass(const double max_threshold,
-                                             const extractor::RoadClassification &classification);
+                                             const RoadClassification &classification);

-    const extractor::intersection::CoordinateExtractor coordinate_extractor;
+    const CoordinateExtractor coordinate_extractor;
 };

 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

-#endif /*OSRM_GUIDANCE_SLIPROAD_HANDLER_HPP_*/
+#endif /*OSRM_EXTRACTOR_GUIDANCE_SLIPROAD_HANDLER_HPP_*/
@@ -1,9 +1,9 @@
-#ifndef OSRM_GUIDANCE_STATISTICS_HANDLER_HPP_
-#define OSRM_GUIDANCE_STATISTICS_HANDLER_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_STATISTICS_HANDLER_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_STATISTICS_HANDLER_HPP_

-#include "guidance/intersection.hpp"
-#include "guidance/intersection_handler.hpp"
-#include "guidance/turn_instruction.hpp"
+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/intersection_handler.hpp"
+#include "extractor/guidance/turn_instruction.hpp"

 #include "util/log.hpp"

@@ -17,6 +17,8 @@

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -26,14 +28,14 @@ class StatisticsHandler final : public IntersectionHandler
 {
  public:
    StatisticsHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                      const extractor::EdgeBasedNodeDataContainer &node_data_container,
+                      const EdgeBasedNodeDataContainer &node_data_container,
                      const std::vector<util::Coordinate> &coordinates,
                      const extractor::CompressedEdgeContainer &compressed_geometries,
-                      const extractor::RestrictionMap &node_restriction_map,
+                      const RestrictionMap &node_restriction_map,
                      const std::unordered_set<NodeID> &barrier_nodes,
-                      const extractor::TurnLanesIndexedArray &turn_lanes_data,
+                      const guidance::TurnLanesIndexedArray &turn_lanes_data,
                      const util::NameTable &name_table,
-                      const extractor::SuffixTable &street_name_suffix_table)
+                      const SuffixTable &street_name_suffix_table)
        : IntersectionHandler(node_based_graph,
                              node_data_container,
                              coordinates,
@@ -108,6 +110,7 @@ class StatisticsHandler final : public IntersectionHandler
 };

 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

-#endif // OSRM_GUIDANCE_VALIDATION_HANDLER_HPP_
+#endif // OSRM_EXTRACTOR_GUIDANCE_VALIDATION_HANDLER_HPP_
@@ -1,12 +1,16 @@
-#ifndef OSRM_GUIDANCE_SUPPRESS_MODE_HANDLER_HPP_
-#define OSRM_GUIDANCE_SUPPRESS_MODE_HANDLER_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_SUPPRESS_MODE_HANDLER_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_SUPPRESS_MODE_HANDLER_HPP_

-#include "guidance/intersection.hpp"
-#include "guidance/intersection_handler.hpp"
+#include "extractor/guidance/constants.hpp"
+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/intersection_handler.hpp"
+#include "extractor/travel_mode.hpp"
 #include "util/node_based_graph.hpp"

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -17,14 +21,14 @@ class SuppressModeHandler final : public IntersectionHandler
 {
  public:
    SuppressModeHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                        const extractor::EdgeBasedNodeDataContainer &node_data_container,
+                        const EdgeBasedNodeDataContainer &node_data_container,
                        const std::vector<util::Coordinate> &coordinates,
                        const extractor::CompressedEdgeContainer &compressed_geometries,
-                        const extractor::RestrictionMap &node_restriction_map,
+                        const RestrictionMap &node_restriction_map,
                        const std::unordered_set<NodeID> &barrier_nodes,
-                        const extractor::TurnLanesIndexedArray &turn_lanes_data,
+                        const guidance::TurnLanesIndexedArray &turn_lanes_data,
                        const util::NameTable &name_table,
-                        const extractor::SuffixTable &street_name_suffix_table);
+                        const SuffixTable &street_name_suffix_table);

    ~SuppressModeHandler() override final = default;

@@ -37,7 +41,8 @@ class SuppressModeHandler final : public IntersectionHandler
                            Intersection intersection) const override final;
 };

-} // namespace guidance
 } // namespace osrm
+} // namespace extractor
+} // namespace guidance

-#endif /* OSRM_GUIDANCE_SUPPRESS_MODE_HANDLER_HPP_ */
+#endif /* OSRM_EXTRACTOR_GUIDANCE_SUPPRESS_MODE_HANDLER_HPP_ */
@@ -1,19 +1,19 @@
-#ifndef OSRM_GUIDANCE_TURN_ANALYSIS
-#define OSRM_GUIDANCE_TURN_ANALYSIS
+#ifndef OSRM_EXTRACTOR_TURN_ANALYSIS
+#define OSRM_EXTRACTOR_TURN_ANALYSIS

 #include "extractor/compressed_edge_container.hpp"
-#include "extractor/intersection/intersection_view.hpp"
+#include "extractor/guidance/driveway_handler.hpp"
+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/motorway_handler.hpp"
+#include "extractor/guidance/roundabout_handler.hpp"
+#include "extractor/guidance/sliproad_handler.hpp"
+#include "extractor/guidance/statistics_handler.hpp"
+#include "extractor/guidance/suppress_mode_handler.hpp"
+#include "extractor/guidance/turn_classification.hpp"
+#include "extractor/guidance/turn_handler.hpp"
+#include "extractor/query_node.hpp"
 #include "extractor/restriction_index.hpp"
 #include "extractor/suffix_table.hpp"
-#include "guidance/driveway_handler.hpp"
-#include "guidance/intersection.hpp"
-#include "guidance/motorway_handler.hpp"
-#include "guidance/roundabout_handler.hpp"
-#include "guidance/sliproad_handler.hpp"
-#include "guidance/statistics_handler.hpp"
-#include "guidance/suppress_mode_handler.hpp"
-#include "guidance/turn_classification.hpp"
-#include "guidance/turn_handler.hpp"

 #include "util/attributes.hpp"
 #include "util/name_table.hpp"
@@ -30,6 +30,8 @@

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -37,14 +39,14 @@ class TurnAnalysis
 {
  public:
    TurnAnalysis(const util::NodeBasedDynamicGraph &node_based_graph,
-                 const extractor::EdgeBasedNodeDataContainer &node_data_container,
+                 const EdgeBasedNodeDataContainer &node_data_container,
                 const std::vector<util::Coordinate> &node_coordinates,
-                 const extractor::CompressedEdgeContainer &compressed_edge_container,
-                 const extractor::RestrictionMap &restriction_map,
+                 const CompressedEdgeContainer &compressed_edge_container,
+                 const RestrictionMap &restriction_map,
                 const std::unordered_set<NodeID> &barrier_nodes,
-                 const extractor::TurnLanesIndexedArray &turn_lanes_data,
+                 const guidance::TurnLanesIndexedArray &turn_lanes_data,
                 const util::NameTable &name_table,
-                 const extractor::SuffixTable &street_name_suffix_table);
+                 const SuffixTable &street_name_suffix_table);

    /* Full Analysis Process for a single node/edge combination. Use with caution, as the process is
     * relatively expensive */
@@ -54,10 +56,9 @@ class TurnAnalysis

    // Select turn types based on the intersection shape
    OSRM_ATTR_WARN_UNUSED
-    Intersection
-    AssignTurnTypes(const NodeID from_node,
-                    const EdgeID via_eid,
-                    const extractor::intersection::IntersectionView &intersection) const;
+    Intersection AssignTurnTypes(const NodeID from_node,
+                                 const EdgeID via_eid,
+                                 const IntersectionView &intersection) const;

  private:
    const util::NodeBasedDynamicGraph &node_based_graph;
@@ -75,6 +76,7 @@ class TurnAnalysis
 }; // class TurnAnalysis

 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

-#endif // OSRM_GUIDANCE_TURN_ANALYSIS
+#endif // OSRM_EXTRACTOR_TURN_ANALYSIS
@@ -1,7 +1,7 @@
 #ifndef OSRM_GUIDANCE_TURN_CLASSIFICATION_HPP_
 #define OSRM_GUIDANCE_TURN_CLASSIFICATION_HPP_

-#include "guidance/intersection.hpp"
+#include "extractor/guidance/intersection.hpp"

 #include "util/coordinate.hpp"
 #include "util/guidance/bearing_class.hpp"
@@ -11,6 +11,8 @@

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -18,6 +20,7 @@ std::pair<util::guidance::EntryClass, util::guidance::BearingClass>
 classifyIntersection(Intersection intersection, const osrm::util::Coordinate &location);

 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

 #endif // OSRM_GUIDANCE_TURN_CLASSIFICATION_HPP_
@@ -1,9 +1,9 @@
-#ifndef OSRM_GUIDANCE_TURN_DISCOVERY_HPP_
-#define OSRM_GUIDANCE_TURN_DISCOVERY_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_TURN_DISCOVERY_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_TURN_DISCOVERY_HPP_

+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/turn_lane_data.hpp"
 #include "extractor/restriction_index.hpp"
-#include "guidance/intersection.hpp"
-#include "guidance/turn_lane_data.hpp"
 #include "util/typedefs.hpp"

 #include <unordered_set>
@@ -12,13 +12,13 @@ namespace osrm
 {
 namespace util
 {
-struct Coordinate;
+class Coordinate;
 }

 namespace extractor
 {
+
 class CompressedEdgeContainer;
-}

 namespace guidance
 {
@@ -34,19 +34,20 @@ bool findPreviousIntersection(
    const EdgeID via_edge,
    const Intersection &intersection,
    const util::NodeBasedDynamicGraph &node_based_graph, // query edge data
-    const extractor::EdgeBasedNodeDataContainer &node_data_container,
+    const EdgeBasedNodeDataContainer &node_data_container,
    const std::vector<util::Coordinate> &node_coordinates,
    const extractor::CompressedEdgeContainer &compressed_geometries,
-    const extractor::RestrictionMap &node_restriction_map,
+    const RestrictionMap &node_restriction_map,
    const std::unordered_set<NodeID> &barrier_nodes,
-    const extractor::TurnLanesIndexedArray &turn_lanes_data,
+    const guidance::TurnLanesIndexedArray &turn_lanes_data,
    // output parameters, will be in an arbitrary state on failure
    NodeID &result_node,
    EdgeID &result_via_edge,
-    extractor::intersection::IntersectionView &result_intersection);
+    IntersectionView &result_intersection);

 } // namespace lanes
 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

-#endif /*OSRM_GUIDANCE_TURN_DISCOVERY_HPP_*/
+#endif /*OSRM_EXTRACTOR_GUIDANCE_TURN_DISCOVERY_HPP_*/
@@ -1,10 +1,9 @@
-#ifndef OSRM_GUIDANCE_TURN_HANDLER_HPP_
-#define OSRM_GUIDANCE_TURN_HANDLER_HPP_
+#ifndef OSRM_EXTRACTOR_GUIDANCE_TURN_HANDLER_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_TURN_HANDLER_HPP_

+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/intersection_handler.hpp"
 #include "extractor/query_node.hpp"
-#include "guidance/intersection.hpp"
-#include "guidance/intersection_handler.hpp"
-#include "guidance/is_through_street.hpp"

 #include "util/attributes.hpp"
 #include "util/name_table.hpp"
@@ -18,6 +17,8 @@

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -26,14 +27,14 @@ class TurnHandler : public IntersectionHandler
 {
  public:
    TurnHandler(const util::NodeBasedDynamicGraph &node_based_graph,
-                const extractor::EdgeBasedNodeDataContainer &node_data_container,
+                const EdgeBasedNodeDataContainer &node_data_container,
                const std::vector<util::Coordinate> &coordinates,
                const extractor::CompressedEdgeContainer &compressed_geometries,
-                const extractor::RestrictionMap &node_restriction_map,
+                const RestrictionMap &node_restriction_map,
                const std::unordered_set<NodeID> &barrier_nodes,
-                const extractor::TurnLanesIndexedArray &turn_lanes_data,
+                const guidance::TurnLanesIndexedArray &turn_lanes_data,
                const util::NameTable &name_table,
-                const extractor::SuffixTable &street_name_suffix_table);
+                const SuffixTable &street_name_suffix_table);

    ~TurnHandler() override final = default;

@@ -111,6 +112,7 @@ class TurnHandler : public IntersectionHandler
 };

 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

-#endif /*OSRM_GUIDANCE_TURN_HANDLER_HPP_*/
+#endif /*OSRM_EXTRACTOR_GUIDANCE_TURN_HANDLER_HPP_*/
@@ -4,12 +4,14 @@
 #include <algorithm>
 #include <cstdint>

-#include "guidance/roundabout_type.hpp"
+#include "extractor/guidance/roundabout_type.hpp"
 #include "util/attributes.hpp"
 #include "util/typedefs.hpp"

 namespace osrm
 {
+namespace extractor
+{
 namespace guidance
 {

@@ -75,11 +77,7 @@ struct TurnInstruction

    TurnType::Enum type : 5;
    DirectionModifier::Enum direction_modifier : 3;
-
-    bool IsUTurn() const
-    {
-        return type != TurnType::NoTurn && direction_modifier == DirectionModifier::UTurn;
-    }
+    // the lane tupel that is used for the turn

    static TurnInstruction INVALID() { return {TurnType::Invalid, DirectionModifier::UTurn}; }

@@ -155,7 +153,7 @@ inline bool operator==(const TurnInstruction lhs, const TurnInstruction rhs)
 // check if a instruction is associated in any form with a roundabout
 inline bool hasRoundaboutType(const TurnInstruction instruction)
 {
-    using namespace guidance::TurnType;
+    using namespace extractor::guidance::TurnType;
    const constexpr TurnType::Enum valid_types[] = {TurnType::EnterRoundabout,
                                                    TurnType::EnterAndExitRoundabout,
                                                    TurnType::EnterRotary,
@@ -176,106 +174,106 @@ inline bool hasRoundaboutType(const TurnInstruction instruction)
    return std::find(first, last, instruction.type) != last;
 }

-inline bool entersRoundabout(const guidance::TurnInstruction instruction)
+inline bool entersRoundabout(const extractor::guidance::TurnInstruction instruction)
 {
-    return (instruction.type == guidance::TurnType::EnterRoundabout ||
-            instruction.type == guidance::TurnType::EnterRotary ||
-            instruction.type == guidance::TurnType::EnterRoundaboutIntersection ||
-            instruction.type == guidance::TurnType::EnterRoundaboutAtExit ||
-            instruction.type == guidance::TurnType::EnterRotaryAtExit ||
-            instruction.type == guidance::TurnType::EnterRoundaboutIntersectionAtExit ||
-            instruction.type == guidance::TurnType::EnterAndExitRoundabout ||
-            instruction.type == guidance::TurnType::EnterAndExitRotary ||
-            instruction.type == guidance::TurnType::EnterAndExitRoundaboutIntersection);
+    return (instruction.type == extractor::guidance::TurnType::EnterRoundabout ||
+            instruction.type == extractor::guidance::TurnType::EnterRotary ||
+            instruction.type == extractor::guidance::TurnType::EnterRoundaboutIntersection ||
+            instruction.type == extractor::guidance::TurnType::EnterRoundaboutAtExit ||
+            instruction.type == extractor::guidance::TurnType::EnterRotaryAtExit ||
+            instruction.type == extractor::guidance::TurnType::EnterRoundaboutIntersectionAtExit ||
+            instruction.type == extractor::guidance::TurnType::EnterAndExitRoundabout ||
+            instruction.type == extractor::guidance::TurnType::EnterAndExitRotary ||
+            instruction.type == extractor::guidance::TurnType::EnterAndExitRoundaboutIntersection);
 }

-inline bool leavesRoundabout(const guidance::TurnInstruction instruction)
+inline bool leavesRoundabout(const extractor::guidance::TurnInstruction instruction)
 {
-    return (instruction.type == guidance::TurnType::ExitRoundabout ||
-            instruction.type == guidance::TurnType::ExitRotary ||
-            instruction.type == guidance::TurnType::ExitRoundaboutIntersection ||
-            instruction.type == guidance::TurnType::EnterAndExitRoundabout ||
-            instruction.type == guidance::TurnType::EnterAndExitRotary ||
-            instruction.type == guidance::TurnType::EnterAndExitRoundaboutIntersection);
+    return (instruction.type == extractor::guidance::TurnType::ExitRoundabout ||
+            instruction.type == extractor::guidance::TurnType::ExitRotary ||
+            instruction.type == extractor::guidance::TurnType::ExitRoundaboutIntersection ||
+            instruction.type == extractor::guidance::TurnType::EnterAndExitRoundabout ||
+            instruction.type == extractor::guidance::TurnType::EnterAndExitRotary ||
+            instruction.type == extractor::guidance::TurnType::EnterAndExitRoundaboutIntersection);
 }

-inline bool staysOnRoundabout(const guidance::TurnInstruction instruction)
+inline bool staysOnRoundabout(const extractor::guidance::TurnInstruction instruction)
 {
-    return instruction.type == guidance::TurnType::StayOnRoundabout ||
-           instruction.type == guidance::TurnType::EnterRoundaboutAtExit ||
-           instruction.type == guidance::TurnType::EnterRotaryAtExit ||
-           instruction.type == guidance::TurnType::EnterRoundaboutIntersectionAtExit;
+    return instruction.type == extractor::guidance::TurnType::StayOnRoundabout ||
+           instruction.type == extractor::guidance::TurnType::EnterRoundaboutAtExit ||
+           instruction.type == extractor::guidance::TurnType::EnterRotaryAtExit ||
+           instruction.type == extractor::guidance::TurnType::EnterRoundaboutIntersectionAtExit;
 }

 // Silent Turn Instructions are not to be mentioned to the outside world but
-inline bool isSilent(const guidance::TurnInstruction instruction)
+inline bool isSilent(const extractor::guidance::TurnInstruction instruction)
 {
-    return instruction.type == guidance::TurnType::NoTurn ||
-           instruction.type == guidance::TurnType::Suppressed ||
-           instruction.type == guidance::TurnType::StayOnRoundabout;
+    return instruction.type == extractor::guidance::TurnType::NoTurn ||
+           instruction.type == extractor::guidance::TurnType::Suppressed ||
+           instruction.type == extractor::guidance::TurnType::StayOnRoundabout;
 }

-inline bool hasRampType(const guidance::TurnInstruction instruction)
+inline bool hasRampType(const extractor::guidance::TurnInstruction instruction)
 {
-    return instruction.type == guidance::TurnType::OffRamp ||
-           instruction.type == guidance::TurnType::OnRamp;
+    return instruction.type == extractor::guidance::TurnType::OffRamp ||
+           instruction.type == extractor::guidance::TurnType::OnRamp;
 }

-inline guidance::DirectionModifier::Enum getTurnDirection(const double angle)
+inline extractor::guidance::DirectionModifier::Enum getTurnDirection(const double angle)
 {
    // An angle of zero is a u-turn
    // 180 goes perfectly straight
    // 0-180 are right turns
    // 180-360 are left turns
    if (angle > 0 && angle < 60)
-        return guidance::DirectionModifier::SharpRight;
+        return extractor::guidance::DirectionModifier::SharpRight;
    if (angle >= 60 && angle < 140)
-        return guidance::DirectionModifier::Right;
+        return extractor::guidance::DirectionModifier::Right;
    if (angle >= 140 && angle < 160)
-        return guidance::DirectionModifier::SlightRight;
+        return extractor::guidance::DirectionModifier::SlightRight;
    if (angle >= 160 && angle <= 200)
-        return guidance::DirectionModifier::Straight;
+        return extractor::guidance::DirectionModifier::Straight;
    if (angle > 200 && angle <= 220)
-        return guidance::DirectionModifier::SlightLeft;
+        return extractor::guidance::DirectionModifier::SlightLeft;
    if (angle > 220 && angle <= 300)
-        return guidance::DirectionModifier::Left;
+        return extractor::guidance::DirectionModifier::Left;
    if (angle > 300 && angle < 360)
-        return guidance::DirectionModifier::SharpLeft;
-    return guidance::DirectionModifier::UTurn;
+        return extractor::guidance::DirectionModifier::SharpLeft;
+    return extractor::guidance::DirectionModifier::UTurn;
 }

 // swaps left <-> right modifier types
 OSRM_ATTR_WARN_UNUSED
-inline guidance::DirectionModifier::Enum
-mirrorDirectionModifier(const guidance::DirectionModifier::Enum modifier)
+inline extractor::guidance::DirectionModifier::Enum
+mirrorDirectionModifier(const extractor::guidance::DirectionModifier::Enum modifier)
 {
-    const constexpr guidance::DirectionModifier::Enum results[] = {
-        guidance::DirectionModifier::UTurn,
-        guidance::DirectionModifier::SharpLeft,
-        guidance::DirectionModifier::Left,
-        guidance::DirectionModifier::SlightLeft,
-        guidance::DirectionModifier::Straight,
-        guidance::DirectionModifier::SlightRight,
-        guidance::DirectionModifier::Right,
-        guidance::DirectionModifier::SharpRight};
+    const constexpr extractor::guidance::DirectionModifier::Enum results[] = {
+        extractor::guidance::DirectionModifier::UTurn,
+        extractor::guidance::DirectionModifier::SharpLeft,
+        extractor::guidance::DirectionModifier::Left,
+        extractor::guidance::DirectionModifier::SlightLeft,
+        extractor::guidance::DirectionModifier::Straight,
+        extractor::guidance::DirectionModifier::SlightRight,
+        extractor::guidance::DirectionModifier::Right,
+        extractor::guidance::DirectionModifier::SharpRight};
    return results[modifier];
 }

-inline bool hasLeftModifier(const guidance::TurnInstruction instruction)
+inline bool hasLeftModifier(const extractor::guidance::TurnInstruction instruction)
 {
-    return instruction.direction_modifier == guidance::DirectionModifier::SharpLeft ||
-           instruction.direction_modifier == guidance::DirectionModifier::Left ||
-           instruction.direction_modifier == guidance::DirectionModifier::SlightLeft;
+    return instruction.direction_modifier == extractor::guidance::DirectionModifier::SharpLeft ||
+           instruction.direction_modifier == extractor::guidance::DirectionModifier::Left ||
+           instruction.direction_modifier == extractor::guidance::DirectionModifier::SlightLeft;
 }

-inline bool hasRightModifier(const guidance::TurnInstruction instruction)
+inline bool hasRightModifier(const extractor::guidance::TurnInstruction instruction)
 {
-    return instruction.direction_modifier == guidance::DirectionModifier::SharpRight ||
-           instruction.direction_modifier == guidance::DirectionModifier::Right ||
-           instruction.direction_modifier == guidance::DirectionModifier::SlightRight;
+    return instruction.direction_modifier == extractor::guidance::DirectionModifier::SharpRight ||
+           instruction.direction_modifier == extractor::guidance::DirectionModifier::Right ||
+           instruction.direction_modifier == extractor::guidance::DirectionModifier::SlightRight;
 }

-inline bool isLeftTurn(const guidance::TurnInstruction instruction)
+inline bool isLeftTurn(const extractor::guidance::TurnInstruction instruction)
 {
    switch (instruction.type)
    {
@@ -286,7 +284,7 @@ inline bool isLeftTurn(const guidance::TurnInstruction instruction)
    }
 }

-inline bool isRightTurn(const guidance::TurnInstruction instruction)
+inline bool isRightTurn(const extractor::guidance::TurnInstruction instruction)
 {
    switch (instruction.type)
    {
@@ -301,14 +299,14 @@ inline DirectionModifier::Enum bearingToDirectionModifier(const double bearing)
 {
    if (bearing < 135)
    {
-        return guidance::DirectionModifier::Right;
+        return extractor::guidance::DirectionModifier::Right;
    }

    if (bearing <= 225)
    {
-        return guidance::DirectionModifier::Straight;
+        return extractor::guidance::DirectionModifier::Straight;
    }
-    return guidance::DirectionModifier::Left;
+    return extractor::guidance::DirectionModifier::Left;
 }

 namespace detail
@@ -321,8 +319,7 @@ const constexpr char *modifier_names[] = {"uturn",
                                          "straight",
                                          "slight left",
                                          "left",
-                                          "sharp left",
-                                          "UNDEFINED"};
+                                          "sharp left"};

 /**
 * Human readable values for TurnType enum values
@@ -336,7 +333,7 @@ struct TurnTypeName
    const char *internal_name;
 };

-// Indexes in this list correspond to the Enum values of osrm::guidance::TurnType
+// Indexes in this list correspond to the Enum values of osrm::extractor::guidance::TurnType
 const constexpr TurnTypeName turn_type_names[] = {
    {"invalid", "(not set)"},
    {"new name", "new name"},
@@ -364,14 +361,13 @@ const constexpr TurnTypeName turn_type_names[] = {
    {"roundabout turn", "roundabout turn"},
    {"exit roundabout", "exit roundabout turn"},
    {"invalid", "(stay on roundabout)"},
-    {"invalid", "(sliproad)"},
-    {"MAXVALUE", "MAXVALUE"}};
+    {"invalid", "(sliproad)"}};

 } // ns detail

 inline std::string instructionTypeToString(const TurnType::Enum type)
 {
-    static_assert((sizeof(detail::turn_type_names) + 1) / sizeof(detail::turn_type_names[0]) >=
+    static_assert(sizeof(detail::turn_type_names) / sizeof(detail::turn_type_names[0]) >=
                      TurnType::MaxTurnType,
                  "Some turn types have no string representation.");
    return detail::turn_type_names[static_cast<std::size_t>(type)].external_name;
@@ -379,7 +375,7 @@ inline std::string instructionTypeToString(const TurnType::Enum type)

 inline std::string internalInstructionTypeToString(const TurnType::Enum type)
 {
-    static_assert((sizeof(detail::turn_type_names) + 1) / sizeof(detail::turn_type_names[0]) >=
+    static_assert(sizeof(detail::turn_type_names) / sizeof(detail::turn_type_names[0]) >=
                      TurnType::MaxTurnType,
                  "Some turn types have no string representation.");
    return detail::turn_type_names[static_cast<std::size_t>(type)].internal_name;
@@ -387,13 +383,14 @@ inline std::string internalInstructionTypeToString(const TurnType::Enum type)

 inline std::string instructionModifierToString(const DirectionModifier::Enum modifier)
 {
-    static_assert((sizeof(detail::modifier_names) + 1) / sizeof(detail::modifier_names[0]) >=
+    static_assert(sizeof(detail::modifier_names) / sizeof(detail::modifier_names[0]) >=
                      DirectionModifier::MaxDirectionModifier,
                  "Some direction modifiers have no string representation.");
    return detail::modifier_names[static_cast<std::size_t>(modifier)];
 }

 } // namespace guidance
+} // namespace extractor
 } // namespace osrm

 #endif // OSRM_GUIDANCE_TURN_INSTRUCTION_HPP_
@@ -0,0 +1,26 @@
+#ifndef OSRM_EXTRACTOR_GUIDANCE_TURN_LANE_AUGMENTATION_HPP_
+#define OSRM_EXTRACTOR_GUIDANCE_TURN_LANE_AUGMENTATION_HPP_
+
+#include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/turn_lane_data.hpp"
+#include "util/attributes.hpp"
+
+namespace osrm
+{
+namespace extractor
+{
+namespace guidance
+{
+namespace lanes
+{
+
+OSRM_ATTR_WARN_UNUSED
+LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
+                                           const Intersection &intersection);
+
+} // namespace lanes
+} // namespace guidance
+} // namespace extractor
+} // namespace osrm
+
+#endif /* OSRM_EXTRACTOR_GUIDANCE_TURN_LANE_AUGMENTATION_HPP_ */
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Patrick Niklaus	d1022043ba	Bumbed version to latest.2	2017-12-18 15:54:19 +00:00
Patrick Niklaus	98566bc7e6	Fix broken assertion after rebase	2017-12-18 15:45:04 +00:00
Michael Krasnyk	9d2e57ac7b	Make distance_between_roads symmetrical	2017-12-18 15:24:14 +00:00
Michael Krasnyk	5effc60819	Reduce extraction distance to 120 meters For intersection at https://www.openstreetmap.org/node/65299217 `are_parallel` in MergableRoadDetector::HaveSameDirection is false for South Van Ness Avenue with 150 meters	2017-12-18 15:24:14 +00:00
Michael Krasnyk	807e4b5ea2	Still use low precision bearings	2017-12-18 15:24:14 +00:00
Michael Krasnyk	deb865d421	Add low precision intersection views back	2017-12-18 15:24:14 +00:00
Michael Krasnyk	dd8dc76c1b	Adjust to review findings	2017-12-18 15:24:14 +00:00
Michael Krasnyk	203036a11d	Remove handling of U-turns on motorways	2017-12-18 15:24:14 +00:00
Michael Krasnyk	22d127bc7c	Move roads re-ordering to convertToIntersectionView	2017-12-18 15:24:14 +00:00
Michael Krasnyk	12dfa709f1	Remove IntersectionGenerator	2017-12-18 12:50:10 +00:00
Michael Krasnyk	1d4d6dca41	Remove GetConnectedRoads from IntersectionGenerator	2017-12-18 12:48:28 +00:00
Michael Krasnyk	1f8b41489c	Remove usage of IntersectionGenerator in EBGF	2017-12-18 12:48:28 +00:00
Michael Krasnyk	68c581c9e6	Free functions for guidance intersections analysis	2017-12-18 12:45:23 +00:00
Michael Krasnyk	0c954fafae	Allow to specify empty bearings string in input parameters	2017-12-18 12:45:23 +00:00
Michael Krasnyk	4316886d4b	Print statistics only for allowed turns	2017-12-18 12:45:23 +00:00