Restrict CMake version to 2.8.11+ for target_include_directories

This reverts commit 7641b12b08.

Conflicts:
	profiles/bicycle.lua
	profiles/car.lua

.clang-format

@@ -2,53 +2,89 @@
 Language:        Cpp
 # BasedOnStyle:  LLVM
 AccessModifierOffset: -2
-ConstructorInitializerIndentWidth: 4
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
 AlignEscapedNewlinesLeft: false
+AlignOperands:   true
 AlignTrailingComments: true
 AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
 AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: true
-AlwaysBreakTemplateDeclarations: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:   
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  true
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  BeforeCatch:     true
+  BeforeElse:      true
+  IndentBraces:    true
 BreakBeforeBinaryOperators: false
+BreakBeforeBraces: Allman
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializersBeforeComma: false
-BinPackParameters: false
 ColumnLimit:     100
+CommentPragmas:  '^ IWYU pragma:'
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
-DerivePointerBinding: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
+ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeCategories: 
+  - Regex:           '^<'
+    Priority:        3
+  - Regex:           '^"(osrm|util|engine|extract|contract)/'
+    Priority:        2
+  - Regex:           '.*'
+    Priority:        1
 IndentCaseLabels: false
-MaxEmptyLinesToKeep: 1
+IndentWidth:     4
+IndentWrappedFunctionNames: false
 KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
 ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: true
 PenaltyBreakBeforeFirstCallParameter: 19
 PenaltyBreakComment: 300
-PenaltyBreakString: 1000
 PenaltyBreakFirstLessLess: 120
-PenaltyExcessCharacter: 1000
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
-PointerBindsToType: false
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 1
-Cpp11BracedListStyle: true
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
 Standard:        Cpp11
-IndentWidth:     4
 TabWidth:        8
 UseTab:          Never
-BreakBeforeBraces: Allman
-IndentFunctionDeclarationAfterType: false
-SpacesInParentheses: false
-SpacesInAngles:  false
-SpaceInEmptyParentheses: false
-SpacesInCStyleCastParentheses: false
-SpacesInContainerLiterals: true
-SpaceBeforeAssignmentOperators: true
-ContinuationIndentWidth: 4
-CommentPragmas:  '^ IWYU pragma:'
-ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
-SpaceBeforeParens: ControlStatements
 ...
 

.travis.yml

@@ -17,6 +17,8 @@ branches:
 cache:
   ccache: true
   apt: true
+  directories:
+    - test/cache
 
 env:
   global:
@@ -47,13 +49,16 @@ matrix:
           packages: ['g++-4.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev', 'ccache']
       env: CCOMPILER='gcc-4.8' CXXCOMPILER='g++-4.8' BUILD_TYPE='Debug'
 
-    - os: linux
-      compiler: "clang-3.8-debug"
-      addons: &clang38
-        apt:
-          sources: ['llvm-toolchain-precise-3.8', 'ubuntu-toolchain-r-test']
-          packages: ['clang-3.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev', 'ccache']
-      env: CCOMPILER='clang-3.8' CXXCOMPILER='clang++-3.8' BUILD_TYPE='Debug' RUN_CLANG_FORMAT=ON
+  # LLVM APT servers switched off, commenting Clang builds out as they will always fail now
+  # http://lists.llvm.org/pipermail/llvm-foundation/2016-June/000025.html
+  #
+  #    - os: linux
+  #      compiler: "clang-3.8-debug"
+  #      addons: &clang38
+  #        apt:
+  #          sources: ['llvm-toolchain-precise-3.8', 'ubuntu-toolchain-r-test']
+  #          packages: ['clang-3.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev', 'ccache']
+  #      env: CCOMPILER='clang-3.8' CXXCOMPILER='clang++-3.8' BUILD_TYPE='Debug' RUN_CLANG_FORMAT=ON
 
     - os: osx
       osx_image: xcode7.3
@@ -112,22 +117,20 @@ matrix:
       #- env: CCOMPILER='clang-3.8' CXXCOMPILER='clang++-3.8' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
 
 before_install:
+  - if [[ $(uname -s) == 'Darwin' ]]; then sudo mdutil -i off /; fi;
   - source ./scripts/install_node.sh 4
   - npm install
   - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
-  - mkdir -p ${DEPS_DIR} && cd ${DEPS_DIR}
+  - export PATH=${DEPS_DIR}/bin:${PATH} && mkdir -p ${DEPS_DIR}
+  - CMAKE_URL="https://mason-binaries.s3.amazonaws.com/${TRAVIS_OS_NAME}-x86_64/cmake/3.5.2.tar.gz"
+  - travis_retry wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C ${DEPS_DIR}
   - |
-    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
-      CMAKE_URL="http://www.cmake.org/files/v3.5/cmake-3.5.1-Linux-x86_64.tar.gz"
-      mkdir cmake && travis_retry wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake
-      export PATH=${DEPS_DIR}/cmake/bin:${PATH}
-    elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
+    if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
       # implicit deps, but seem to be installed by default with recent images: libxml2 GDAL boost
-      brew install cmake libzip libstxxl lua51 luabind tbb md5sha1sum ccache
+      brew install libzip libstxxl lua51 luabind tbb md5sha1sum ccache
     fi
 
 install:
-  - cd ${TRAVIS_BUILD_DIR}
   - |
     if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
       ./scripts/check_taginfo.py taginfo.json profiles/car.lua
@@ -171,7 +174,7 @@ script:
 after_success:
   - |
     if [ -n "${RUN_CLANG_FORMAT}" ]; then
-      ./scripts/format.sh || true # we don't want to fail just yet
+      ./scripts/format.sh # we don't want to fail just yet
     fi
   - |
     if [ -n "${COVERAGE}" ]; then

CHANGELOG.md

@@ -1,3 +1,28 @@
+# 5.2.0 RC2
+   Changes from 5.2.0 RC1
+
+   - Guidance:
+     - improved handling of sliproads (emit turns instead of 'take the ramp')
+     - BREAKING: modifies the file format with new internal identifiers
+
+   - API:
+     - paramater `annotate` was renamed to `annotations`.
+     - `annotation` as accidentally placed in `Route` instead of `RouteLeg`
+     - Support for destination signs. New member `destinations` in `RouteStep`, based on `destination` and `destination:ref`
+     - Support for name pronounciations. New member `pronounciation` in `RouteStep`, based on `name:pronounciation`
+     - Add `nodes` property to `annotation` in `RouteLeg` containing the ids of nodes covered by the route
+
+   - Profile changes:
+     - `result.destinations` allows you to set a way's destinations
+     - `result.pronounciation` allows you to set way name pronounciations
+     - `highway=motorway_link` no longer implies `oneway` as per the OSM Wiki
+
+   - Infrastructure
+     - BREAKING: Changed the on-disk encoding of the StaticRTree to reduce ramIndex file size. This breaks the **data format**
+
+   - Bugfixes
+     - fixed broken summaries for very short routes
+
 # 5.2.0 RC1
    Changes from 5.1.0
 

CMakeLists.txt

@@ -1,4 +1,5 @@
-cmake_minimum_required(VERSION 2.8.8)
+cmake_minimum_required(VERSION 2.8.11)
+# we depend on 2.8.11 introducing target_include_directories
 
 if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE)
   message(FATAL_ERROR "In-source builds are not allowed.
@@ -316,7 +317,8 @@ set(ENGINE_LIBRARIES
     ${STXXL_LIBRARY}
     ${TBB_LIBRARIES}
     ${MAYBE_RT_LIBRARY}
-    ${MAYBE_COVERAGE_LIBRARIES})
+    ${MAYBE_COVERAGE_LIBRARIES}
+    ${ZLIB_LIBRARY})
 set(STORAGE_LIBRARIES
     ${Boost_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}

cmake/FindTBB.cmake

@@ -280,4 +280,5 @@ if (TBB_FOUND)
 	FILE(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _TBB_VERSION_CONTENTS)
 	STRING(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_TBB_VERSION_CONTENTS}")
 	set(TBB_INTERFACE_VERSION "${TBB_INTERFACE_VERSION}")
+        message(STATUS "TBB interface version: ${TBB_INTERFACE_VERSION}")
 endif (TBB_FOUND)

docs/http.md

@@ -151,7 +151,7 @@ http://router.project-osrm.org/nearest/v1/driving/13.388860,52.517037?number=3&b
 ### Request
 
 ```
-http://{server}/route/v1/{profile}/{coordinates}?alternatives={true|false}&steps={true|false}&geometries={polyline|geojson}&overview={full|simplified|false}
+http://{server}/route/v1/{profile}/{coordinates}?alternatives={true|false}&steps={true|false}&geometries={polyline|geojson}&overview={full|simplified|false}&annotations={true|false}
 ```
 
 In addition to the [general options](#general-options) the following options are supported for this service:
@@ -160,7 +160,7 @@ In addition to the [general options](#general-options) the following options are
 |------------|------------------------------------------|-------------------------------------------------------------------------------|
 |alternatives|`true`, `false` (default)                 |Search for alternative routes and return as well.\*                            |
 |steps       |`true`, `false` (default)                 |Return route steps for each route leg                                          |
-|annotate    |`true`, `false` (default)                 |Returns additional metadata for each coordinate along the route geometry.      |
+|annotations |`true`, `false` (default)                 |Returns additional metadata for each coordinate along the route geometry.      |
 |geometries  |`polyline` (default), `geojson`           |Returned route geometry format (influences overview and per step)             |
 |overview    |`simplified` (default), `full`, `false`   |Add overview geometry either full, simplified according to highest zoom level it could be display on, or not at all.|
 |continue_straight |`default` (default), `true`, `false`|Forces the route to keep going straight at waypoints and don't do a uturn even if it would be faster. Default value depends on the profile. |
@@ -253,7 +253,7 @@ The algorithm might not be able to match all points. Outliers are removed if the
 ### Request
 
 ```
-http://{server}/match/v1/{profile}/{coordinates}?steps={true|false}&geometries={polyline|geojson}&overview={simplified|full|false}
+http://{server}/match/v1/{profile}/{coordinates}?steps={true|false}&geometries={polyline|geojson}&overview={simplified|full|false}&annotations={true|false}
 ```
 
 In addition to the [general options](#general-options) the following options are supported for this service:
@@ -263,7 +263,7 @@ In addition to the [general options](#general-options) the following options are
 |------------|------------------------------------------------|------------------------------------------------------------------------------------------|
 |steps       |`true`, `false` (default)                       |Return route steps for each route                                                         |
 |geometries  |`polyline` (default), `geojson`                 |Returned route geometry format (influences overview and per step)                        |
-|annotate    |`true`, `false` (default)                       |Returns additional metadata for each coordinate along the route geometry.                |
+|annotations |`true`, `false` (default)                       |Returns additional metadata for each coordinate along the route geometry.                |
 |overview    |`simplified` (default), `full`, `false`         |Add overview geometry either full, simplified according to highest zoom level it could be display on, or not at all.|
 |timestamps  |`{timestamp};{timestamp}[;{timestamp} ...]`     |Timestamp of the input location.                                                          |
 |radiuses    |`{radius};{radius}[;{radius} ...]`              |Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy.|
@@ -301,7 +301,7 @@ multiple trips for each connected component are returned.
 ### Request
 
 ```
-http://{server}/trip/v1/{profile}/{coordinates}?steps={true|false}&geometries={polyline|geojson}&overview={simplified|full|false}
+http://{server}/trip/v1/{profile}/{coordinates}?steps={true|false}&geometries={polyline|geojson}&overview={simplified|full|false}&annotations={true|false}
 ```
 
 In addition to the [general options](#general-options) the following options are supported for this service:
@@ -309,7 +309,7 @@ In addition to the [general options](#general-options) the following options are
 |Option      |Values                                          |Description                                                                |
 |------------|------------------------------------------------|---------------------------------------------------------------------------|
 |steps       |`true`, `false` (default)                       |Return route instructions for each trip                                    |
-|annotate    |`true`, `false` (default)                       |Returns additional metadata for each coordinate along the route geometry.      |
+|annotations |`true`, `false` (default)                       |Returns additional metadata for each coordinate along the route geometry.      |
 |geometries  |`polyline` (default), `geojson`                 |Returned route geometry format (influences overview and per step)         |
 |overview    |`simplified` (default), `full`, `false`         |Add overview geometry either full, simplified according to highest zoom level it could be display on, or not at all.|
 
@@ -397,14 +397,14 @@ Represents a route between two waypoints.
 
 - `annotation`: Additional details about each coordinate along the route geometry:
 
-   | annotate     |                                                                       |
+   | annotations  |                                                                       |
    |--------------|-----------------------------------------------------------------------|
    | true         | returns distance and durations of each coordinate along the route     |
    | false        | will not exist                                                        |
 
 #### Example
 
-With `steps=false` and `annotate=true`:
+With `steps=false` and `annotations=true`:
 
 ```json
 {
@@ -413,7 +413,8 @@ With `steps=false` and `annotate=true`:
   "steps": []
   "annotation": {
     "distance": [5,5,10,5,5],
-    "duration": [15,15,40,15,15]
+    "duration": [15,15,40,15,15],
+    "nodes": [49772551,49772552,49786799,49786800,49786801,49786802]
   }
 }
 ```
@@ -436,6 +437,8 @@ step.
   | geojson    | [GeoJSON `LineString`](http://geojson.org/geojson-spec.html#linestring) or [GeoJSON `Point`](http://geojson.org/geojson-spec.html#point) if it is only one coordinate (not wrapped by a GeoJSON feature)|
   
 - `name`: The name of the way along which travel proceeds.
+- `pronunciation`: The pronunciation hint of the way name. Will be `undefined` if there is no pronunciation hit.
+- `destinations`: The destinations of the way. Will be `undefined` if there are no destinations.
 - `mode`: A string signifying the mode of transportation.
 - `maneuver`: A `StepManeuver` object representing the maneuver.
 - `intersections`: A list of `Intersections` that are passed along the segment, the very first belonging to the StepManeuver

example/example.cpp

@@ -1,20 +1,20 @@
+#include "osrm/match_parameters.hpp"
+#include "osrm/nearest_parameters.hpp"
 #include "osrm/route_parameters.hpp"
 #include "osrm/table_parameters.hpp"
-#include "osrm/nearest_parameters.hpp"
 #include "osrm/trip_parameters.hpp"
-#include "osrm/match_parameters.hpp"
 
 #include "osrm/coordinate.hpp"
 #include "osrm/engine_config.hpp"
 #include "osrm/json_container.hpp"
 
-#include "osrm/status.hpp"
 #include "osrm/osrm.hpp"
+#include "osrm/status.hpp"
 
+#include <exception>
+#include <iostream>
 #include <string>
 #include <utility>
-#include <iostream>
-#include <exception>
 
 #include <cstdlib>
 

features/bicycle/oneway.feature

@@ -48,22 +48,22 @@ Feature: Bike - Oneway streets
 
     Scenario: Bike - Implied oneways
         Then routability should be
-            | highway       | foot | bicycle | junction   | forw | backw |
-            |               | no   |         |            | x    | x     |
-            |               | no   |         | roundabout | x    |       |
-            | motorway      | no   | yes     |            | x    |       |
-            | motorway_link | no   | yes     |            | x    |       |
-            | motorway      | no   | yes     | roundabout | x    |       |
-            | motorway_link | no   | yes     | roundabout | x    |       |
+            | highway         | foot | bicycle | junction   | forw | backw | #                     |
+            |                 | no   |         |            | x    | x     |                       |
+            |                 | no   |         | roundabout | x    |       |                       |
+            | motorway        | no   | yes     |            | x    |       |                       |
+            | motorway_link   | no   | yes     |            | x    | x     | does not imply oneway |
+            | motorway        | no   | yes     | roundabout | x    |       |                       |
+            | motorway_link   | no   | yes     | roundabout | x    |       |                       |
 
     Scenario: Bike - Overriding implied oneways
         Then routability should be
-            | highway       | foot | junction   | oneway | forw | backw |
-            | primary       | no   | roundabout | no     | x    | x     |
-            | primary       | no   | roundabout | yes    | x    |       |
-            | motorway_link | no   |            | -1     |      |       |
-            | trunk_link    | no   |            | -1     |      |       |
-            | primary       | no   | roundabout | -1     |      | x     |
+            | highway         | foot | junction   | oneway | forw | backw |
+            | primary         | no   | roundabout | no     | x    | x     |
+            | primary         | no   | roundabout | yes    | x    |       |
+            | motorway_link   | no   |            | -1     |      |       |
+            | trunk_link      | no   |            | -1     |      |       |
+            | primary         | no   | roundabout | -1     |      | x     |
 
     Scenario: Bike - Oneway:bicycle should override normal oneways tags
         Then routability should be

features/car/names.feature

@@ -18,6 +18,23 @@ Feature: Car - Street names in instructions
             | from | to | route                              |
             | a    | c  | My Way,Your Way (A1),Your Way (A1) |
 
+    Scenario: Car - A named street with pronunciation
+        Given the node map
+            | a | b | d |
+            |   | 1 |   |
+            |   | c |   |
+
+        And the ways
+            | nodes | name     |name:pronunciation | ref |
+            | ab    | My Way   |                    |     |
+            | bd    | My Way   | meyeway            | A1  |
+            | cd    | Your Way | yourewaye          |     |
+
+        When I route I should get
+            | from | to | route              | pronunciations      |
+            | a    | d  | My Way,My Way (A1) | ,meyeway             |
+            | 1    | c  | Your Way,Your Way  | yourewaye,yourewaye  |
+
     @todo
     Scenario: Car - Use way type to describe unnamed ways
         Given the node map

features/car/oneway.feature

@@ -17,19 +17,21 @@ Feature: Car - Oneway streets
 
     Scenario: Car - Implied oneways
         Then routability should be
-            | highway       | junction   | forw | backw |
-            | motorway      |            | x    |       |
-            | motorway_link |            | x    |       |
-            | primary       |            | x    | x     |
-            | motorway      | roundabout | x    |       |
-            | motorway_link | roundabout | x    |       |
-            | primary       | roundabout | x    |       |
+            | highway         | junction   | forw | backw | #                     |
+            | motorway        |            | x    |       |                       |
+            | motorway_link   |            | x    | x     | does not imply oneway |
+            | primary         |            | x    | x     |                       |
+            | motorway        | roundabout | x    |       |                       |
+            | motorway_link   | roundabout | x    |       |                       |
+            | primary         | roundabout | x    |       |                       |
 
     Scenario: Car - Overrule implied oneway
         Then routability should be
-            | highway       | oneway | forw | backw |
-            | motorway      | no     | x    | x     |
-            | motorway_link | no     | x    | x     |
+            | highway       | oneway | forw | backw | #                    |
+            | motorway      | no     | x    | x     |                      |
+            | motorway_link | no     | x    | x     |                      |
+            | motorway_link | yes    | x    |       |                      |
+            | motorway_link |        | x    | x     | does not imply onway |
 
     Scenario: Car - Around the Block
         Given the node map

features/guidance/dedicated-turn-roads.feature

@@ -0,0 +1,125 @@
+@routing  @guidance
+Feature: Slipways and Dedicated Turn Lanes
+
+    Background:
+        Given the profile "car"
+        Given a grid size of 5 meters
+
+    Scenario: Turn Instead of Ramp
+        Given the node map
+            |   |   |   |   | e |   |
+            | a | b |   |   | c | d |
+            |   |   |   | h |   |   |
+            |   |   |   |   |   |   |
+            |   |   |   | 1 |   |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   | f |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   | g |   |
+
+        And the ways
+            | nodes | highway    | name   |
+            | abcd  | trunk      | first  |
+            | bhf   | trunk_link |        |
+            | ecfg  | primary    | second |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction   |
+            | restriction | abcd     | ecfg   | c        | no_right_turn |
+
+       When I route I should get
+            | waypoints | route               | turns                           |
+            | a,g       | first,second,second | depart,turn right,arrive        |
+            | a,1       | first,,             | depart,turn slight right,arrive |
+
+    Scenario: Turn Instead of Ramp
+        Given the node map
+            |   |   |   |   | e |   |
+            | a | b |   |   | c | d |
+            |   |   |   | h |   |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   | f |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   | g |   |
+
+        And the ways
+            | nodes | highway       | name   |
+            | abcd  | motorway      | first  |
+            | bhf   | motorway_link |        |
+            | efg   | primary       | second |
+
+       When I route I should get
+            | waypoints | route                | turns                                                 |
+            | a,g       | first,,second,second | depart,off ramp slight right,merge slight left,arrive |
+
+    Scenario: Inner city expressway with on road
+        Given the node map
+            | a | b |   |   |   | c |
+            |   |   |   |   | f |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   |   | d |
+            |   |   |   |   |   |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   |   |   |
+            |   |   |   |   |   | e |
+
+        And the ways
+            | nodes | highway      | name  |
+            | abc   | primary      | road  |
+            | bfd   | trunk_link   |       |
+            | cde   | trunk        | trunk |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction   |
+            | restriction | abc      | cde    | c        | no_right_turn |
+
+       When I route I should get
+            | waypoints | route                | turns                    |
+            | a,e       | road,trunk,trunk     | depart,turn right,arrive |
+
+
+    Scenario: Slipway Round U-Turn
+        Given the node map
+            | a |   | f |
+            |   |   |   |
+            | b |   | e |
+            |   |   |   |
+            |   |   |   |
+            |   | g |   |
+            |   |   |   |
+            | c |   | d |
+
+        And the ways
+            | nodes | highway      | name | oneway |
+            | abc   | primary      | road | yes    |
+            | bge   | primary_link |      | yes    |
+            | def   | primary      | road | yes    |
+
+       When I route I should get
+            | waypoints | route          | turns                        |
+            | a,f       | road,road,road | depart,continue uturn,arrive |
+
+    Scenario: Slipway Steep U-Turn
+        Given the node map
+            | a |   | f |
+            |   |   |   |
+            | b |   | e |
+            |   | g |   |
+            |   |   |   |
+            |   |   |   |
+            | c |   | d |
+
+        And the ways
+            | nodes | highway      | name | oneway |
+            | abc   | primary      | road | yes    |
+            | bge   | primary_link |      | yes    |
+            | def   | primary      | road | yes    |
+
+       When I route I should get
+            | waypoints | route          | turns                        |
+            | a,f       | road,road,road | depart,continue uturn,arrive |

features/guidance/destination-signs.feature

@@ -29,13 +29,13 @@ Feature: Destination Signs
           | qr    | QR   |     |                | A1;A2           | yes    |                                      |
 
         When I route I should get
-          | from | to | route                                                     | #                         |
-          | a    | b  | AB (E1),AB (E1)                                           |                           |
-          | c    | d  | CD (Berlin),CD (Berlin)                                   |                           |
-          | e    | f  | EF (A1: Berlin),EF (A1: Berlin)                           |                           |
-          | g    | h  | ,                                                         |                           |
-          | i    | j  | ,                                                         |                           |
-          | k    | l  | KL (E1),KL (E1)                                           |                           |
-          | m    | n  | MN (A1, A2: Berlin, Hamburg),MN (A1, A2: Berlin, Hamburg) |                           |
-          | o    | p  | OP,OP                                                     | guard against mis-tagging |
-          | q    | r  | QR (A1, A2),QR (A1, A2)                                   |                           |
+          | from | to | route                                                     | destinations                                    | #                         |
+          | a    | b  | AB (E1),AB (E1)                                           | ,                                               |                           |
+          | c    | d  | CD (Berlin),CD (Berlin)                                   | Berlin,Berlin                                   |                           |
+          | e    | f  | EF (A1: Berlin),EF (A1: Berlin)                           | A1: Berlin,A1: Berlin                           |                           |
+          | g    | h  | ,                                                         | A1: Berlin,A1: Berlin                           |                           |
+          | i    | j  | ,                                                         | Berlin,Berlin                                   |                           |
+          | k    | l  | KL (E1),KL (E1)                                           | A1: Berlin,A1: Berlin                           |                           |
+          | m    | n  | MN (A1, A2: Berlin, Hamburg),MN (A1, A2: Berlin, Hamburg) | A1, A2: Berlin, Hamburg,A1, A2: Berlin, Hamburg |                           |
+          | o    | p  | OP,OP                                                     | ,                                               | guard against mis-tagging |
+          | q    | r  | QR (A1, A2),QR (A1, A2)                                   | A1, A2,A1, A2                                   |                           |

features/guidance/motorway.feature

@@ -11,9 +11,9 @@ Feature: Motorway Guidance
             |   |   |   | f | g |
 
         And the ways
-            | nodes  | highway       |
-            | abcde  | motorway      |
-            | bfg    | motorway_link |
+            | nodes | highway       | oneway |
+            | abcde | motorway      |        |
+            | bfg   | motorway_link | yes    |
 
        When I route I should get
             | waypoints | route         | turns                                |
@@ -27,9 +27,9 @@ Feature: Motorway Guidance
             |   |   |   | g | e |
 
         And the ways
-            | nodes  | highway       |
-            | abcde  | motorway      |
-            | bfg    | motorway_link |
+            | nodes | highway       | oneway |
+            | abcde | motorway      |        |
+            | bfg   | motorway_link | yes    |
 
        When I route I should get
             | waypoints | route         | turns                         |
@@ -44,9 +44,9 @@ Feature: Motorway Guidance
 
 
         And the ways
-            | nodes  | highway       |
-            | abcde  | motorway      |
-            | cfg    | motorway_link |
+            | nodes | highway       | oneway |
+            | abcde | motorway      |        |
+            | cfg   | motorway_link | yes    |
 
        When I route I should get
             | waypoints | route         | turns                                |
@@ -60,9 +60,9 @@ Feature: Motorway Guidance
             | a | b | c | d | e |
 
         And the ways
-            | nodes  | highway       |
-            | abcde  | motorway      |
-            | bfg    | motorway_link |
+            | nodes | highway       | oneway |
+            | abcde | motorway      |        |
+            | bfg   | motorway_link | yes    |
 
        When I route I should get
             | waypoints | route         | turns                               |
@@ -76,9 +76,9 @@ Feature: Motorway Guidance
             | a | b | c |   |   |
 
         And the ways
-            | nodes  | highway       |
-            | abcde  | motorway      |
-            | bfg    | motorway_link |
+            | nodes | highway       | oneway |
+            | abcde | motorway      |        |
+            | bfg   | motorway_link | yes    |
 
        When I route I should get
             | waypoints | route         | turns                        |
@@ -92,9 +92,9 @@ Feature: Motorway Guidance
             |   |   |   |   | e |
 
         And the ways
-            | nodes  | highway       |
-            | abcde  | motorway      |
-            | cfg    | motorway_link |
+            | nodes | highway       | oneway |
+            | abcde | motorway      |        |
+            | cfg   | motorway_link | yes    |
 
        When I route I should get
             | waypoints | route         | turns                               |
@@ -107,9 +107,9 @@ Feature: Motorway Guidance
             | f | g |   |   |   |
 
         And the ways
-            | nodes  | highway       |
-            | abcde  | motorway      |
-            | fgd    | motorway_link |
+            | nodes | highway       | oneway |
+            | abcde | motorway      |        |
+            | fgd   | motorway_link | yes    |
 
        When I route I should get
             | waypoints | route           | turns                           |
@@ -122,9 +122,9 @@ Feature: Motorway Guidance
             | a | b | c | d | e |
 
         And the ways
-            | nodes  | highway       |
-            | abcde  | motorway      |
-            | fgd    | motorway_link |
+            | nodes | highway       | oneway |
+            | abcde | motorway      |        |
+            | fgd   | motorway_link | yes    |
 
        When I route I should get
             | waypoints | route           | turns                            |
@@ -154,10 +154,10 @@ Feature: Motorway Guidance
             |   |   |   |   | f | g |
 
         And the ways
-            | nodes  | highway       |
-            | abc    | motorway_link |
-            | cde    | motorway      |
-            | cfg    | motorway      |
+            | nodes | highway       | oneway |
+            | abc   | motorway_link | yes    |
+            | cde   | motorway      |        |
+            | cfg   | motorway      |        |
 
        When I route I should get
             | waypoints | route       | turns                           |
@@ -170,17 +170,17 @@ Feature: Motorway Guidance
             | f | g |   |   |   | h | i |
 
         And the ways
-            | nodes  | highway       |
-            | abcde  | motorway      |
-            | fgc    | motorway_link |
-            | chi    | motorway_link |
+            | nodes | highway       | oneway |
+            | abcde | motorway      |        |
+            | fgc   | motorway_link | yes    |
+            | chi   | motorway_link | yes    |
 
        When I route I should get
-            | waypoints | route           | turns                                |
-            | a,e       | abcde,abcde     | depart,arrive                        |
-            | f,e       | fgc,abcde,abcde | depart,merge slight left,arrive      |
+            | waypoints | route           | turns                              |
+            | a,e       | abcde,abcde     | depart,arrive                      |
+            | f,e       | fgc,abcde,abcde | depart,merge slight left,arrive    |
             | a,i       | abcde,chi,chi   | depart,off ramp slight right,arrive |
-            | f,i       | fgc,chi,chi     | depart,off ramp right,arrive        |
+            | f,i       | fgc,chi,chi     | depart,off ramp right,arrive       |
 
     Scenario: On And Off Ramp Left
        Given the node map
@@ -188,17 +188,17 @@ Feature: Motorway Guidance
             | a | b |   | c |   | d | e |
 
         And the ways
-            | nodes  | highway       |
-            | abcde  | motorway      |
-            | fgc    | motorway_link |
-            | chi    | motorway_link |
+            | nodes | highway       | oneway |
+            | abcde | motorway      |        |
+            | fgc   | motorway_link | yes    |
+            | chi   | motorway_link | yes    |
 
        When I route I should get
-            | waypoints | route           | turns                               |
-            | a,e       | abcde,abcde     | depart,arrive                       |
-            | f,e       | fgc,abcde,abcde | depart,merge slight right,arrive    |
+            | waypoints | route           | turns                             |
+            | a,e       | abcde,abcde     | depart,arrive                     |
+            | f,e       | fgc,abcde,abcde | depart,merge slight right,arrive  |
             | a,i       | abcde,chi,chi   | depart,off ramp slight left,arrive |
-            | f,i       | fgc,chi,chi     | depart,off ramp left,arrive        |
+            | f,i       | fgc,chi,chi     | depart,off ramp left,arrive       |
 
     Scenario: Merging Motorways
         Given the node map

features/guidance/roundabout-turn.feature

@@ -367,3 +367,25 @@ Feature: Basic Roundabout
            | h,d       | gh,cd,cd | depart,roundabout-exit-2,arrive |
            | h,f       | gh,ef,ef | depart,roundabout-exit-1,arrive |
 
+    Scenario: Enter and Exit -- Bearing
+        Given the node map
+           |   |   | a |   |   |
+           |   |   | b |   |   |
+           | h | g |   | c | d |
+           |   |   | e |   |   |
+           |   |   | f |   |   |
+
+       And the ways
+            | nodes | junction   |
+            | ab    |            |
+            | cd    |            |
+            | ef    |            |
+            | gh    |            |
+            | bgecb | roundabout |
+
+       When I route I should get
+           | waypoints | route    | turns                                         | bearing                |
+           | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive     | 0->180,180->224,90->0  |
+           | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive | 0->180,180->224,180->0 |
+           | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive    | 0->180,180->224,270->0 |
+

features/guidance/roundabout.feature

@@ -337,3 +337,27 @@ Feature: Basic Roundabout
             | a,e       | ac,de,de | depart,roundabout-exit-1,arrive |
             | a,f       | ac,bf,bf | depart,roundabout-exit-2,arrive |
 
+    Scenario: Enter and Exit - Bearings
+        Given the node map
+            |   |   |   | a |   |   |   |
+            |   |   |   |   |   |   |   |
+            |   |   | i | b | l |   |   |
+            | h |   | g |   | c |   | d |
+            |   |   | j | e | k |   |   |
+            |   |   |   |   |   |   |   |
+            |   |   |   | f |   |   |   |
+
+       And the ways
+            | nodes      | junction   |
+            | ab         |            |
+            | cd         |            |
+            | ef         |            |
+            | gh         |            |
+            | bigjekclb  | roundabout |
+
+       When I route I should get
+           | waypoints | route    | turns                           | bearing                |
+           | a,d       | ab,cd,cd | depart,roundabout-exit-3,arrive | 0->180,180->270,90->0  |
+           | a,f       | ab,ef,ef | depart,roundabout-exit-2,arrive | 0->180,180->270,180->0 |
+           | a,h       | ab,gh,gh | depart,roundabout-exit-1,arrive | 0->180,180->270,270->0 |
+

features/options/contract/datasources.feature

@@ -0,0 +1,30 @@
+@prepare @options @files
+Feature: osrm-contract command line options: datasources
+# expansions:
+# {extracted_base} => path to current extracted input file
+# {profile} => path to current profile script
+
+    Background:
+        Given the profile "testbot"
+        Given the extract extra arguments "--generate-edge-lookup"
+        And the node map
+            | a | b |
+        And the ways
+            | nodes |
+            | ab    |
+        And the speed file
+        """
+        1,2,27
+        2,1,27
+        2,3,27
+        3,2,27
+        1,4,27
+        4,1,27
+        """
+        And the data has been extracted
+
+    Scenario: osrm-contract - Passing base file
+        When I run "osrm-contract --segment-speed-file speeds.csv {extracted_base}.osrm"
+        Then stderr should be empty
+        And datasource names should contain "lua profile,speeds"
+        And it should exit with code 0

features/step_definitions/data.js

@@ -228,14 +228,17 @@ module.exports = function () {
     });
 
     this.Given(/^the raster source$/, (data, callback) => {
+        this.updateFingerprintExtract(data);
         fs.writeFile(path.resolve(this.TEST_FOLDER, 'rastersource.asc'), data, callback);
     });
 
     this.Given(/^the speed file$/, (data, callback) => {
+        this.updateFingerprintContract(data);
         fs.writeFile(path.resolve(this.TEST_FOLDER, 'speeds.csv'), data, callback);
     });
 
     this.Given(/^the turn penalty file$/, (data, callback) => {
+        this.updateFingerprintContract(data);
         fs.writeFile(path.resolve(this.TEST_FOLDER, 'penalties.csv'), data, callback);
     });
 
@@ -249,9 +252,11 @@ module.exports = function () {
     });
 
     this.Given(/^the data has been extracted$/, (callback) => {
-        this.writeAndExtract((err) => {
-            if (err) this.processError = err;
-            callback();
+        this.osmData.populate(() => {
+            this.writeAndExtract((err) => {
+                if (err) this.processError = err;
+                callback();
+            });
         });
     });
 

features/step_definitions/matching.js

@@ -34,7 +34,8 @@ module.exports = function () {
                         turns = '',
                         route = '',
                         duration = '',
-                        annotation = '';
+                        annotation = '',
+                        OSMIDs = '';
 
 
                     if (res.statusCode === 200) {
@@ -61,6 +62,11 @@ module.exports = function () {
                             if (json.matchings.length != 1) throw new Error('*** Checking annotation only supported for matchings with one subtrace');
                             annotation = this.annotationList(json.matchings[0]);
                         }
+
+                        if (headers.has('OSM IDs')) {
+                            if (json.matchings.length != 1) throw new Error('*** CHecking annotation only supported for matchings with one subtrace');
+                            OSMIDs = this.OSMIDList(json.matchings[0]);
+                        }
                     }
 
                     if (headers.has('turns')) {
@@ -79,6 +85,10 @@ module.exports = function () {
                         got.annotation = annotation.toString();
                     }
 
+                    if (headers.has('OSM IDs')) {
+                        got['OSM IDs'] = OSMIDs;
+                    }
+
                     var ok = true;
                     var encodedResult = '',
                         extendedTarget = '';
@@ -145,7 +155,6 @@ module.exports = function () {
                     this.requestUrl(row.request, afterRequest);
                 } else {
                     var params = this.queryParams;
-                    params['annotate'] = 'true';
                     got = {};
                     for (var k in row) {
                         var match = k.match(/param:(.*)/);

features/step_definitions/options.js

@@ -1,4 +1,5 @@
 var assert = require('assert');
+var fs = require('fs');
 
 module.exports = function () {
     this.When(/^I run "osrm\-routed\s?(.*?)"$/, { timeout: this.TIMEOUT }, (options, callback) => {
@@ -59,6 +60,11 @@ module.exports = function () {
         assert.equal(this.stdout.split('\n').length - 1, parseInt(lines));
     });
 
+    this.Then(/^datasource names should contain "(.+)"$/, (expectedData) => {
+        var actualData = fs.readFileSync(this.osmData.extractedFile + '.osrm.datasource_names', {encoding:'UTF-8'}).trim().split('\n').join(',');
+        assert.equal(actualData, expectedData);
+    });
+
     this.Given(/^the query options$/, (table, callback) => {
         table.raw().forEach(tuple => {
             this.queryParams[tuple[0]] = tuple[1];

features/step_definitions/routability.js

@@ -12,7 +12,8 @@ module.exports = function () {
                 throw new Error('*** routability table must contain either "forw", "backw" or "bothw" column');
             }
 
-            this.reprocessAndLoadData(() => {
+            this.reprocessAndLoadData((e) => {
+                if (e) callback(e);
                 var testRow = (row, i, cb) => {
                     var outputRow = row;
 

features/support/config.js

@@ -50,22 +50,27 @@ module.exports = function () {
         };
 
         var hashExtract = (cb) => {
-            this.hashOfFiles(util.format('%s/osrm-extract%s', this.BIN_PATH, this.EXE), (hash) => {
+            var files = [ util.format('%s/osrm-extract%s', this.BIN_PATH, this.EXE),
+                          util.format('%s/libosrm_extract%s', this.BIN_PATH, this.LIB) ];
+            this.hashOfFiles(files, (hash) => {
                 this.binExtractHash = hash;
                 cb();
             });
         };
 
         var hashContract = (cb) => {
-            this.hashOfFiles(util.format('%s/osrm-contract%s', this.BIN_PATH, this.EXE), (hash) => {
+            var files = [ util.format('%s/osrm-contract%s', this.BIN_PATH, this.EXE),
+                          util.format('%s/libosrm_contract%s', this.BIN_PATH, this.LIB) ];
+            this.hashOfFiles(files, (hash) => {
                 this.binContractHash = hash;
-                this.fingerprintContract = this.hashString(this.binContractHash);
                 cb();
             });
         };
 
         var hashRouted = (cb) => {
-            this.hashOfFiles(util.format('%s/osrm-routed%s', this.BIN_PATH, this.EXE), (hash) => {
+            var files = [ util.format('%s/osrm-routed%s', this.BIN_PATH, this.EXE),
+                          util.format('%s/libosrm%s', this.BIN_PATH, this.LIB) ];
+            this.hashOfFiles(files, (hash) => {
                 this.binRoutedHash = hash;
                 this.fingerprintRoute = this.hashString(this.binRoutedHash);
                 cb();
@@ -79,16 +84,18 @@ module.exports = function () {
             .defer(hashContract)
             .defer(hashRouted)
             .awaitAll(() => {
-                this.fingerprintExtract = this.hashString([this.profileHash, this.luaLibHash, this.binExtractHash].join('-'));
                 this.AfterConfiguration(() => {
                     callback();
                 });
             });
     };
 
-    this.setProfileBasedHashes = () => {
-        this.fingerprintExtract = this.hashString([this.profileHash, this.luaLibHash, this.binExtractHash].join('-'));
-        this.fingerprintContract = this.hashString(this.binContractHash);
+    this.updateFingerprintExtract = (str) => {
+        this.fingerprintExtract = this.hashString([this.fingerprintExtract, str].join('-'));
+    };
+
+    this.updateFingerprintContract = (str) => {
+        this.fingerprintContract = this.hashString([this.fingerprintContract, str].join('-'));
     };
 
     this.setProfile = (profile, cb) => {
@@ -97,22 +104,24 @@ module.exports = function () {
             this.profile = profile;
             this.hashProfile((hash) => {
                 this.profileHash = hash;
-                this.setProfileBasedHashes();
+                this.updateFingerprintExtract(this.profileHash);
                 cb();
             });
-        } else cb();
+        } else {
+            this.updateFingerprintExtract(this.profileHash);
+            cb();
+        }
     };
 
     this.setExtractArgs = (args, callback) => {
         this.extractArgs = args;
-        this.forceExtract = true;
-        this.forceContract = true;
+        this.updateFingerprintExtract(args);
         callback();
     };
 
     this.setContractArgs = (args, callback) => {
         this.contractArgs = args;
-        this.forceContract = true;
+        this.updateFingerprintContract(args);
         callback();
     };
 };

features/support/data.js

@@ -194,8 +194,8 @@ module.exports = function () {
     this.extractData = (callback) => {
         this.logPreprocessInfo();
         this.log(util.format('== Extracting %s.osm...', this.osmData.osmFile), 'preprocess');
-        var cmd = util.format('%s%s/osrm-extract %s.osm %s --profile %s/%s.lua >>%s 2>&1',
-            this.LOAD_LIBRARIES, this.BIN_PATH, this.osmData.osmFile, this.extractArgs || '', this.PROFILES_PATH, this.profile, this.PREPROCESS_LOG_FILE);
+        var cmd = util.format('%s/osrm-extract %s.osm %s --profile %s/%s.lua >>%s 2>&1',
+            this.BIN_PATH, this.osmData.osmFile, this.extractArgs || '', this.PROFILES_PATH, this.profile, this.PREPROCESS_LOG_FILE);
         this.log(cmd);
         process.chdir(this.TEST_FOLDER);
         exec(cmd, (err) => {
@@ -222,11 +222,12 @@ module.exports = function () {
                 });
             };
 
-            ['osrm','osrm.names','osrm.restrictions','osrm.ebg','osrm.enw','osrm.edges','osrm.fileIndex','osrm.geometry','osrm.nodes','osrm.ramIndex','osrm.properties','osrm.icd'].forEach(file => {
-                q.defer(rename, file);
-            });
+            ['osrm', 'osrm.ebg', 'osrm.edges', 'osrm.enw', 'osrm.fileIndex', 'osrm.geometry', 'osrm.icd',
+             'osrm.names', 'osrm.nodes', 'osrm.properties', 'osrm.ramIndex', 'osrm.restrictions'].forEach(file => {
+                 q.defer(rename, file);
+             });
 
-            ['osrm.edge_segment_lookup','osrm.edge_penalties'].forEach(file => {
+            ['osrm.edge_penalties', 'osrm.edge_segment_lookup'].forEach(file => {
                 q.defer(renameIfExists, file);
             });
 
@@ -241,8 +242,8 @@ module.exports = function () {
     this.contractData = (callback) => {
         this.logPreprocessInfo();
         this.log(util.format('== Contracting %s.osm...', this.osmData.extractedFile), 'preprocess');
-        var cmd = util.format('%s%s/osrm-contract %s %s.osrm >>%s 2>&1',
-            this.LOAD_LIBRARIES, this.BIN_PATH, this.contractArgs || '', this.osmData.extractedFile, this.PREPROCESS_LOG_FILE);
+        var cmd = util.format('%s/osrm-contract %s %s.osrm >>%s 2>&1',
+            this.BIN_PATH, this.contractArgs || '', this.osmData.extractedFile, this.PREPROCESS_LOG_FILE);
         this.log(cmd);
         process.chdir(this.TEST_FOLDER);
         exec(cmd, (err) => {
@@ -260,6 +261,13 @@ module.exports = function () {
                 });
             };
 
+            var renameIfExists = (file, cb) => {
+                fs.stat([this.osmData.extractedFile, file].join('.'), (doesNotExistErr, exists) => {
+                    if (exists) rename(file, cb);
+                    else cb();
+                });
+            };
+
             var copy = (file, cb) => {
                 this.log(util.format('Copying %s.%s to %s.%s', this.osmData.extractedFile, file, this.osmData.contractedFile, file), 'preprocess');
                 fs.createReadStream([this.osmData.extractedFile, file].join('.'))
@@ -273,11 +281,17 @@ module.exports = function () {
 
             var q = d3.queue();
 
-            ['osrm.hsgr','osrm.fileIndex','osrm.geometry','osrm.nodes','osrm.ramIndex','osrm.core','osrm.edges','osrm.datasource_indexes','osrm.datasource_names','osrm.level','osrm.icd'].forEach((file) => {
-                q.defer(rename, file);
+            ['osrm', 'osrm.core', 'osrm.datasource_indexes', 'osrm.datasource_names', 'osrm.ebg','osrm.edges',
+             'osrm.enw', 'osrm.fileIndex', 'osrm.geometry', 'osrm.hsgr', 'osrm.icd','osrm.level', 'osrm.names',
+             'osrm.nodes', 'osrm.properties', 'osrm.ramIndex', 'osrm.restrictions'].forEach((file) => {
+                 q.defer(rename, file);
+             });
+
+            ['osrm.edge_penalties', 'osrm.edge_segment_lookup'].forEach(file => {
+                q.defer(renameIfExists, file);
             });
 
-            ['osrm.names','osrm.restrictions','osrm.properties','osrm'].forEach((file) => {
+            [].forEach((file) => {
                 q.defer(copy, file);
             });
 
@@ -292,32 +306,33 @@ module.exports = function () {
     var noop = (cb) => cb();
 
     this.reprocess = (callback) => {
-        this.writeAndExtract((e) => {
-            if (e) return callback(e);
+        this.osmData.populate(() => {
             this.isContracted((isContracted) => {
-                var contractFn = (isContracted && !this.forceContract) ? noop : this.contractData;
-                if (isContracted) this.log('Already contracted ' + this.osmData.contractedFile, 'preprocess');
-                contractFn((e) => {
-                    this.forceContract = false;
-                    if (e) return callback(e);
-                    this.logPreprocessDone();
+                if (!isContracted) {
+                    this.writeAndExtract((e) => {
+                        if (e) return callback(e);
+                        this.contractData((e) => {
+                            if (e) return callback(e);
+                            this.logPreprocessDone();
+                            callback();
+                        });
+                    });
+                } else {
+                    this.log('Already contracted ' + this.osmData.contractedFile, 'preprocess');
                     callback();
-                });
+                }
             });
         });
     };
 
     this.writeAndExtract = (callback) => {
-        this.osmData.populate(() => {
-            this.writeInputData((e) => {
-                if (e) return callback(e);
-                this.isExtracted((isExtracted) => {
-                    var extractFn = (isExtracted && !this.forceExtract) ? noop : this.extractData;
-                    if (isExtracted) this.log('Already extracted ' + this.osmData.extractedFile, 'preprocess');
-                    extractFn((e) => {
-                        this.forceExtract = false;
-                        callback(e);
-                    });
+        this.writeInputData((e) => {
+            if (e) return callback(e);
+            this.isExtracted((isExtracted) => {
+                var extractFn = isExtracted ? noop : this.extractData;
+                if (isExtracted) this.log('Already extracted ' + this.osmData.extractedFile, 'preprocess');
+                extractFn((e) => {
+                    callback(e);
                 });
             });
         });

features/support/env.js

@@ -7,7 +7,7 @@ var d3 = require('d3-queue');
 module.exports = function () {
     this.initializeEnv = (callback) => {
         this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
-        this.TIMEOUT = process.env.CUCUMBER_TIMEOUT && parseInt(process.env.CUCUMBER_TIMEOUT) || 3000;
+        this.TIMEOUT = process.env.CUCUMBER_TIMEOUT && parseInt(process.env.CUCUMBER_TIMEOUT) || 5000;
         this.setDefaultTimeout(this.TIMEOUT);
         this.ROOT_FOLDER = process.cwd();
         this.OSM_USER = 'osrm';
@@ -28,19 +28,16 @@ module.exports = function () {
         this.OSRM_ROUTED_LOG_FILE = path.resolve(this.TEST_FOLDER, 'osrm-routed.log');
         this.ERROR_LOG_FILE = path.resolve(this.TEST_FOLDER, 'error.log');
 
-        // OS X shim to ensure shared libraries from custom locations can be loaded
-        // This is needed in OS X >= 10.11 because DYLD_LIBRARY_PATH is blocked
-        // https://forums.developer.apple.com/thread/9233
-        this.LOAD_LIBRARIES = process.env.OSRM_SHARED_LIBRARY_PATH ? util.format('DYLD_LIBRARY_PATH=%s ', process.env.OSRM_SHARED_LIBRARY_PATH) : '';
-
         // TODO make sure this works on win
         if (process.platform.match(/indows.*/)) {
             this.TERMSIGNAL = 9;
             this.EXE = '.exe';
+            this.LIB = '.dll';
             this.QQ = '"';
         } else {
             this.TERMSIGNAL = 'SIGTERM';
             this.EXE = '';
+            this.LIB = '.so';
             this.QQ = '';
         }
 
@@ -65,7 +62,7 @@ module.exports = function () {
             var binPath = path.resolve(util.format('%s/%s%s', this.BIN_PATH, bin, this.EXE));
             fs.exists(binPath, (exists) => {
                 if (!exists) throw new Error(util.format('%s is missing. Build failed?', binPath));
-                var helpPath = util.format('%s%s --help > /dev/null 2>&1', this.LOAD_LIBRARIES, binPath);
+                var helpPath = util.format('%s --help > /dev/null 2>&1', binPath);
                 exec(helpPath, (err) => {
                     if (err) {
                         this.log(util.format('*** Exited with code %d', err.code), 'preprocess');

features/support/hash.js

@@ -6,14 +6,19 @@ var d3 = require('d3-queue');
 module.exports = function () {
     this.hashOfFiles = (paths, cb) => {
         paths = Array.isArray(paths) ? paths : [paths];
-        var shasum = crypto.createHash('sha1');
+        var shasum = crypto.createHash('sha1'), hashedFiles = false;
 
         var q = d3.queue(1);
 
         var addFile = (path, cb) => {
             fs.readFile(path, (err, data) => {
-                shasum.update(data);
-                cb(err);
+                if (err && err.code === 'ENOENT') cb(); // ignore non-existing files
+                else if (err) cb(err);
+                else {
+                    shasum.update(data);
+                    hashedFiles = true;
+                    cb();
+                }
             });
         };
 
@@ -21,6 +26,7 @@ module.exports = function () {
 
         q.awaitAll(err => {
             if (err) throw new Error('*** Error reading files:', err);
+            if (!hashedFiles) throw new Error('*** No files found: [' + paths.join(', ') + ']');
             cb(shasum.digest('hex'));
         });
     };

features/support/hooks.js

@@ -20,6 +20,8 @@ module.exports = function () {
         this.hasLoggedScenarioInfo = false;
         this.setGridSize(this.DEFAULT_GRID_SIZE);
         this.setOrigin(this.DEFAULT_ORIGIN);
+        this.fingerprintExtract = this.hashString([this.luaLibHash, this.binExtractHash].join('-'));
+        this.fingerprintContract = this.hashString(this.binContractHash);
         callback();
     });
 

features/support/launch_classes.js

@@ -1,9 +1,9 @@
 'use strict';
 
 var fs = require('fs');
-var net = require('net');
 var spawn = require('child_process').spawn;
 var util = require('util');
+var net = require('net');
 var Timeout = require('node-timeout');
 
 var OSRMBaseLoader = class {
@@ -15,9 +15,7 @@ var OSRMBaseLoader = class {
         var limit = Timeout(this.scope.TIMEOUT, { err: this.scope.RoutedError('Launching osrm-routed timed out.') });
 
         var runLaunch = (cb) => {
-            this.osrmUp(() => {
-                this.waitForConnection(cb);
-            });
+            this.osrmUp(() => { this.waitForConnection(cb); });
         };
 
         runLaunch(limit((e) => { if (e) callback(e); else callback(); }));
@@ -46,18 +44,21 @@ var OSRMBaseLoader = class {
     }
 
     waitForConnection (callback) {
-        net.connect({
-            port: this.scope.OSRM_PORT,
-            host: '127.0.0.1'
-        })
-            .on('connect', () => {
-                callback();
-            })
-            .on('error', (e) => {
-                setTimeout(() => {
-                    callback(e);
-                }, 100);
-            });
+        var retryCount = 0;
+        var connectWithRetry = () => {
+            net.connect({ port: this.scope.OSRM_PORT, host: '127.0.0.1' })
+               .on('connect', () => { callback(); })
+               .on('error', () => {
+                   if (retryCount < 2) {
+                       retryCount++;
+                       setTimeout(connectWithRetry, 100);
+                   } else {
+                       callback(new Error('Could not connect to osrm-routed after three retires'));
+                   }
+               });
+        };
+
+        connectWithRetry();
     }
 
     waitForShutdown (callback) {
@@ -86,7 +87,7 @@ var OSRMDirectLoader = class extends OSRMBaseLoader {
             fs.appendFile(this.scope.OSRM_ROUTED_LOG_FILE, data, (err) => { if (err) throw err; });
         };
 
-        var child = spawn(util.format('%s%s/osrm-routed', this.scope.LOAD_LIBRARIES, this.scope.BIN_PATH), [this.inputFile, util.format('-p%d', this.scope.OSRM_PORT)]);
+        var child = spawn(util.format('%s/osrm-routed', this.scope.BIN_PATH), [this.inputFile, util.format('-p%d', this.scope.OSRM_PORT)]);
         this.scope.pid = child.pid;
         child.stdout.on('data', writeToLog);
         child.stderr.on('data', writeToLog);
@@ -122,7 +123,7 @@ var OSRMDatastoreLoader = class extends OSRMBaseLoader {
             fs.appendFile(this.scope.OSRM_ROUTED_LOG_FILE, data, (err) => { if (err) throw err; });
         };
 
-        var child = spawn(util.format('%s%s/osrm-routed', this.scope.LOAD_LIBRARIES, this.scope.BIN_PATH), ['--shared-memory=1', util.format('-p%d', this.scope.OSRM_PORT)]);
+        var child = spawn(util.format('%s/osrm-routed', this.scope.BIN_PATH), ['--shared-memory=1', util.format('-p%d', this.scope.OSRM_PORT)]);
         this.child = child;
         this.scope.pid = child.pid;
         child.stdout.on('data', writeToLog);
@@ -148,7 +149,7 @@ module.exports = {
                 this.loader = new OSRMDirectLoader(this.scope);
                 this.loader.load(inputFile, callback);
             } else {
-                throw new Error('*** Unknown load method ' + method);
+                callback(new Error('*** Unknown load method ' + method));
             }
         }
 

features/support/route.js

@@ -1,3 +1,5 @@
+'use strict';
+
 var Timeout = require('node-timeout');
 var request = require('request');
 
@@ -137,18 +139,33 @@ module.exports = function () {
         return this.extractInstructionList(instructions, s => s.name);
     };
 
+    this.pronunciationList = (instructions) => {
+        return this.extractInstructionList(instructions, s => s.pronunciation || '');
+    };
+
+    this.destinationsList = (instructions) => {
+        return this.extractInstructionList(instructions, s => s.destinations || '');
+    };
+
     this.bearingList = (instructions) => {
         return this.extractInstructionList(instructions, s => s.maneuver.bearing_before + '->' + s.maneuver.bearing_after);
     };
 
     this.annotationList = (instructions) => {
-        // Pull out all the distinct segment distances, skipping the arrive
-        // instructions, and the leading 0 on all timestamps arrays.
-        var pairs = [];
-        for (var i in instructions.annotation.duration) {
-            pairs.push(instructions.annotation.duration[i]+':'+instructions.annotation.distance[i]);
+        function zip(list_1, list_2)
+        {
+            let pairs = [];
+            for (let i = 0; i <  list_1.length; ++i) {
+                pairs.push([list_1[i], list_2[i]]);
+            }
+            return pairs;
         }
-        return pairs.join(',');
+        return instructions.legs.map(l => {return zip(l.annotation.duration, l.annotation.distance).map(p => { return p.join(':'); }).join(','); }).join(',');
+    };
+
+    this.OSMIDList = (instructions) => {
+        // OSM node IDs also come from the annotation list
+        return instructions.legs.map(l => l.annotation.nodes.map(n => n.toString()).join(',')).join(',');
     };
 
     this.turnList = (instructions) => {

features/support/run.js

@@ -25,7 +25,7 @@ module.exports = function () {
             opts = opts.replace('{profile}', [this.PROFILES_PATH, this.profile + '.lua'].join('/'));
         }
 
-        var cmd = util.format('%s%s%s/%s%s%s %s 2>%s', this.QQ, this.LOAD_LIBRARIES, this.BIN_PATH, bin, this.EXE, this.QQ, opts, this.ERROR_LOG_FILE);
+        var cmd = util.format('%s%s/%s%s%s %s 2>%s', this.QQ, this.BIN_PATH, bin, this.EXE, this.QQ, opts, this.ERROR_LOG_FILE);
         process.chdir(this.TEST_FOLDER);
         exec(cmd, (err, stdout, stderr) => {
             this.stdout = stdout.toString();

features/support/shared_steps.js

@@ -1,3 +1,5 @@
+'use strict';
+
 var util = require('util');
 var assert = require('assert');
 
@@ -31,14 +33,16 @@ module.exports = function () {
                 var afterRequest = (err, res, body) => {
                     if (err) return cb(err);
                     if (body && body.length) {
-                        var instructions, bearings, turns, modes, times, distances, summary, intersections;
+                        let destinations, pronunciations, instructions, bearings, turns, modes, times, distances, summary, intersections;
 
-                        var json = JSON.parse(body);
+                        let json = JSON.parse(body);
 
-                        var hasRoute = json.code === 'Ok';
+                        let hasRoute = json.code === 'Ok';
 
                         if (hasRoute) {
                             instructions = this.wayList(json.routes[0]);
+                            pronunciations = this.pronunciationList(json.routes[0]);
+                            destinations = this.destinationsList(json.routes[0]);
                             bearings = this.bearingList(json.routes[0]);
                             turns = this.turnList(json.routes[0]);
                             intersections = this.intersectionList(json.routes[0]);
@@ -122,6 +126,8 @@ module.exports = function () {
                             putValue('modes', modes);
                             putValue('times', times);
                             putValue('distances', distances);
+                            putValue('pronunciations', pronunciations);
+                            putValue('destinations', destinations);
                         }
 
                         var ok = true;

features/testbot/matching.feature

@@ -106,6 +106,9 @@ Feature: Basic Map Matching
             | efgh  | ab,bc,cd  |
 
     Scenario: Testbot - Duration details
+        Given the query options
+            | annotations | true |
+
         Given the node map
             | a | b | c | d | e |   | g | h |
             |   |   | i |   |   |   |   |   |
@@ -119,3 +122,9 @@ Feature: Basic Map Matching
             | trace | matchings | annotation                                                                     |
             | abeh  | abcedgh   | 1:9.897633,0:0,1:10.008842,1:10.008842,1:10.008842,0:0,2:20.017685,1:10.008842 |
             | abci  | abc,ci    | 1:9.897633,0:0,1:10.008842,0:0.111209,1:10.010367                              |
+
+        # The following is the same as the above, but separated for readability (line length)
+        When I match I should get
+            | trace | matchings | OSM IDs               |
+            | abeh  | abcedgh   | 1,2,3,2,3,4,5,4,5,6,7 |
+            | abci  | abc,ci    | 1,2,3,2,3,8,3,8       |

features/testbot/summary.feature

@@ -7,7 +7,7 @@ Feature: Basic Routing
     @smallest
     Scenario: Checking 
         Given the node map
-            | a | b |  | c | d | e |
+            | a | b | 1 | c | d | e |
 
         And the ways
             | nodes |
@@ -22,6 +22,7 @@ Feature: Basic Routing
             | e    | a  | de,cd,bc,ab,ab | de, bc   |
             | a    | b  | ab,ab          | ab       |
             | b    | d  | bc,cd,cd       | bc, cd   |
+            | 1    | c  | bc,bc          | bc       |
 
     @smallest
     Scenario: Check handling empty values

include/contractor/contractor.hpp

@@ -32,11 +32,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "contractor/query_edge.hpp"
 #include "extractor/edge_based_edge.hpp"
 #include "extractor/edge_based_node.hpp"
-#include "util/typedefs.hpp"
 #include "util/deallocating_vector.hpp"
+#include "util/typedefs.hpp"
 
-#include <vector>
 #include <string>
+#include <vector>
 
 #include <cstddef>
 

include/contractor/graph_contractor.hpp

@@ -1,17 +1,17 @@
 #ifndef GRAPH_CONTRACTOR_HPP
 #define GRAPH_CONTRACTOR_HPP
 
+#include "contractor/query_edge.hpp"
 #include "util/binary_heap.hpp"
 #include "util/deallocating_vector.hpp"
 #include "util/dynamic_graph.hpp"
-#include "util/percent.hpp"
-#include "contractor/query_edge.hpp"
-#include "util/xor_fast_hash.hpp"
-#include "util/xor_fast_hash_storage.hpp"
 #include "util/integer_range.hpp"
+#include "util/percent.hpp"
 #include "util/simple_logger.hpp"
 #include "util/timing_util.hpp"
 #include "util/typedefs.hpp"
+#include "util/xor_fast_hash.hpp"
+#include "util/xor_fast_hash_storage.hpp"
 
 #include <boost/assert.hpp>
 
@@ -165,14 +165,22 @@ class GraphContractor
                     << static_cast<unsigned int>(diter->target);
             }
 #endif
-            edges.emplace_back(diter->source, diter->target,
-                               static_cast<unsigned int>(std::max(diter->weight, 1)), 1,
-                               diter->edge_id, false, diter->forward ? true : false,
+            edges.emplace_back(diter->source,
+                               diter->target,
+                               static_cast<unsigned int>(std::max(diter->weight, 1)),
+                               1,
+                               diter->edge_id,
+                               false,
+                               diter->forward ? true : false,
                                diter->backward ? true : false);
 
-            edges.emplace_back(diter->target, diter->source,
-                               static_cast<unsigned int>(std::max(diter->weight, 1)), 1,
-                               diter->edge_id, false, diter->backward ? true : false,
+            edges.emplace_back(diter->target,
+                               diter->source,
+                               static_cast<unsigned int>(std::max(diter->weight, 1)),
+                               1,
+                               diter->edge_id,
+                               false,
+                               diter->backward ? true : false,
                                diter->forward ? true : false);
         }
         // clear input vector
@@ -276,8 +284,7 @@ class GraphContractor
         std::vector<RemainingNodeData> remaining_nodes(number_of_nodes);
         // initialize priorities in parallel
         tbb::parallel_for(tbb::blocked_range<int>(0, number_of_nodes, InitGrainSize),
-                          [this, &remaining_nodes](const tbb::blocked_range<int> &range)
-                          {
+                          [this, &remaining_nodes](const tbb::blocked_range<int> &range) {
                               for (int x = range.begin(), end = range.end(); x != end; ++x)
                               {
                                   remaining_nodes[x].id = x;
@@ -299,9 +306,8 @@ class GraphContractor
 
             std::cout << "initializing elimination PQ ..." << std::flush;
             tbb::parallel_for(tbb::blocked_range<int>(0, number_of_nodes, PQGrainSize),
-                              [this, &node_priorities, &node_depth,
-                               &thread_data_list](const tbb::blocked_range<int> &range)
-                              {
+                              [this, &node_priorities, &node_depth, &thread_data_list](
+                                  const tbb::blocked_range<int> &range) {
                                   ContractorThreadData *data = thread_data_list.GetThreadData();
                                   for (int x = range.begin(), end = range.end(); x != end; ++x)
                                   {
@@ -342,7 +348,8 @@ class GraphContractor
                 // remaining graph
                 std::vector<NodeID> new_node_id_from_orig_id_map(number_of_nodes, SPECIAL_NODEID);
 
-                for (const auto new_node_id : util::irange<std::size_t>(0UL, remaining_nodes.size()))
+                for (const auto new_node_id :
+                     util::irange<std::size_t>(0UL, remaining_nodes.size()))
                 {
                     auto &node = remaining_nodes[new_node_id];
                     BOOST_ASSERT(node_priorities.size() > node.id);
@@ -352,7 +359,8 @@ class GraphContractor
                 }
 
                 // build forward and backward renumbering map and remap ids in remaining_nodes
-                for (const auto new_node_id : util::irange<std::size_t>(0UL, remaining_nodes.size()))
+                for (const auto new_node_id :
+                     util::irange<std::size_t>(0UL, remaining_nodes.size()))
                 {
                     auto &node = remaining_nodes[new_node_id];
                     // create renumbering maps in both directions
@@ -378,7 +386,8 @@ class GraphContractor
                             // node is not yet contracted.
                             // add (renumbered) outgoing edges to new util::DynamicGraph.
                             ContractorEdge new_edge = {new_node_id_from_orig_id_map[source],
-                                                       new_node_id_from_orig_id_map[target], data};
+                                                       new_node_id_from_orig_id_map[target],
+                                                       data};
 
                             new_edge.data.is_original_via_node_ID = true;
                             BOOST_ASSERT_MSG(SPECIAL_NODEID != new_node_id_from_orig_id_map[source],
@@ -421,9 +430,8 @@ class GraphContractor
 
             tbb::parallel_for(
                 tbb::blocked_range<std::size_t>(0, remaining_nodes.size(), IndependentGrainSize),
-                [this, &node_priorities, &remaining_nodes,
-                 &thread_data_list](const tbb::blocked_range<std::size_t> &range)
-                {
+                [this, &node_priorities, &remaining_nodes, &thread_data_list](
+                    const tbb::blocked_range<std::size_t> &range) {
                     ContractorThreadData *data = thread_data_list.GetThreadData();
                     // determine independent node set
                     for (auto i = range.begin(), end = range.end(); i != end; ++i)
@@ -436,8 +444,7 @@ class GraphContractor
 
             // sort all remaining nodes to the beginning of the sequence
             const auto begin_independent_nodes = stable_partition(
-                remaining_nodes.begin(), remaining_nodes.end(), [](RemainingNodeData node_data)
-                {
+                remaining_nodes.begin(), remaining_nodes.end(), [](RemainingNodeData node_data) {
                     return !node_data.is_independent;
                 });
             auto begin_independent_nodes_idx =
@@ -448,11 +455,10 @@ class GraphContractor
             {
                 // write out contraction level
                 tbb::parallel_for(
-                    tbb::blocked_range<std::size_t>(begin_independent_nodes_idx,
-                                                    end_independent_nodes_idx, ContractGrainSize),
-                    [this, remaining_nodes, flushed_contractor,
-                     current_level](const tbb::blocked_range<std::size_t> &range)
-                    {
+                    tbb::blocked_range<std::size_t>(
+                        begin_independent_nodes_idx, end_independent_nodes_idx, ContractGrainSize),
+                    [this, remaining_nodes, flushed_contractor, current_level](
+                        const tbb::blocked_range<std::size_t> &range) {
                         if (flushed_contractor)
                         {
                             for (int position = range.begin(), end = range.end(); position != end;
@@ -475,26 +481,24 @@ class GraphContractor
             }
 
             // contract independent nodes
-            tbb::parallel_for(tbb::blocked_range<std::size_t>(begin_independent_nodes_idx,
-                                                              end_independent_nodes_idx,
-                                                              ContractGrainSize),
-                              [this, &remaining_nodes,
-                               &thread_data_list](const tbb::blocked_range<std::size_t> &range)
-                              {
-                                  ContractorThreadData *data = thread_data_list.GetThreadData();
-                                  for (int position = range.begin(), end = range.end();
-                                       position != end; ++position)
-                                  {
-                                      const NodeID x = remaining_nodes[position].id;
-                                      this->ContractNode<false>(data, x);
-                                  }
-                              });
+            tbb::parallel_for(
+                tbb::blocked_range<std::size_t>(
+                    begin_independent_nodes_idx, end_independent_nodes_idx, ContractGrainSize),
+                [this, &remaining_nodes, &thread_data_list](
+                    const tbb::blocked_range<std::size_t> &range) {
+                    ContractorThreadData *data = thread_data_list.GetThreadData();
+                    for (int position = range.begin(), end = range.end(); position != end;
+                         ++position)
+                    {
+                        const NodeID x = remaining_nodes[position].id;
+                        this->ContractNode<false>(data, x);
+                    }
+                });
 
             tbb::parallel_for(
-                tbb::blocked_range<int>(begin_independent_nodes_idx, end_independent_nodes_idx,
-                                        DeleteGrainSize),
-                [this, &remaining_nodes, &thread_data_list](const tbb::blocked_range<int> &range)
-                {
+                tbb::blocked_range<int>(
+                    begin_independent_nodes_idx, end_independent_nodes_idx, DeleteGrainSize),
+                [this, &remaining_nodes, &thread_data_list](const tbb::blocked_range<int> &range) {
                     ContractorThreadData *data = thread_data_list.GetThreadData();
                     for (int position = range.begin(), end = range.end(); position != end;
                          ++position)
@@ -507,8 +511,7 @@ class GraphContractor
             // make sure we really sort each block
             tbb::parallel_for(
                 thread_data_list.data.range(),
-                [&](const ThreadDataContainer::EnumerableThreadData::range_type &range)
-                {
+                [&](const ThreadDataContainer::EnumerableThreadData::range_type &range) {
                     for (auto &data : range)
                         tbb::parallel_sort(data->inserted_edges.begin(),
                                            data->inserted_edges.end());
@@ -542,11 +545,11 @@ class GraphContractor
             if (!use_cached_node_priorities)
             {
                 tbb::parallel_for(
-                    tbb::blocked_range<int>(begin_independent_nodes_idx, end_independent_nodes_idx,
+                    tbb::blocked_range<int>(begin_independent_nodes_idx,
+                                            end_independent_nodes_idx,
                                             NeighboursGrainSize),
-                    [this, &node_priorities, &remaining_nodes, &node_depth,
-                     &thread_data_list](const tbb::blocked_range<int> &range)
-                    {
+                    [this, &node_priorities, &remaining_nodes, &node_depth, &thread_data_list](
+                        const tbb::blocked_range<int> &range) {
                         ContractorThreadData *data = thread_data_list.GetThreadData();
                         for (int position = range.begin(), end = range.end(); position != end;
                              ++position)
@@ -570,8 +573,7 @@ class GraphContractor
             if (orig_node_id_from_new_node_id_map.size() > 0)
             {
                 tbb::parallel_for(tbb::blocked_range<int>(0, remaining_nodes.size(), InitGrainSize),
-                                  [this, &remaining_nodes](const tbb::blocked_range<int> &range)
-                                  {
+                                  [this, &remaining_nodes](const tbb::blocked_range<int> &range) {
                                       for (int x = range.begin(), end = range.end(); x != end; ++x)
                                       {
                                           const auto orig_id = remaining_nodes[x].id;
@@ -583,8 +585,7 @@ class GraphContractor
             else
             {
                 tbb::parallel_for(tbb::blocked_range<int>(0, remaining_nodes.size(), InitGrainSize),
-                                  [this, &remaining_nodes](const tbb::blocked_range<int> &range)
-                                  {
+                                  [this, &remaining_nodes](const tbb::blocked_range<int> &range) {
                                       for (int x = range.begin(), end = range.end(); x != end; ++x)
                                       {
                                           const auto orig_id = remaining_nodes[x].id;
@@ -843,15 +844,25 @@ class GraphContractor
                             // guarantees that source is not connected to another node that is
                             // contracted
                             node_weights[source] = path_distance; // make sure to prune better
-                            inserted_edges.emplace_back(
-                                source, target, path_distance,
-                                out_data.originalEdges + in_data.originalEdges, node, SHORTCUT_ARC,
-                                FORWARD_DIRECTION_ENABLED, REVERSE_DIRECTION_DISABLED);
+                            inserted_edges.emplace_back(source,
+                                                        target,
+                                                        path_distance,
+                                                        out_data.originalEdges +
+                                                            in_data.originalEdges,
+                                                        node,
+                                                        SHORTCUT_ARC,
+                                                        FORWARD_DIRECTION_ENABLED,
+                                                        REVERSE_DIRECTION_DISABLED);
 
-                            inserted_edges.emplace_back(
-                                target, source, path_distance,
-                                out_data.originalEdges + in_data.originalEdges, node, SHORTCUT_ARC,
-                                FORWARD_DIRECTION_DISABLED, REVERSE_DIRECTION_ENABLED);
+                            inserted_edges.emplace_back(target,
+                                                        source,
+                                                        path_distance,
+                                                        out_data.originalEdges +
+                                                            in_data.originalEdges,
+                                                        node,
+                                                        SHORTCUT_ARC,
+                                                        FORWARD_DIRECTION_DISABLED,
+                                                        REVERSE_DIRECTION_ENABLED);
                         }
                     }
                     continue;
@@ -867,8 +878,8 @@ class GraphContractor
             if (RUNSIMULATION)
             {
                 const int constexpr SIMULATION_SEARCH_SPACE_SIZE = 1000;
-                Dijkstra(max_distance, number_of_targets, SIMULATION_SEARCH_SPACE_SIZE, *data,
-                         node);
+                Dijkstra(
+                    max_distance, number_of_targets, SIMULATION_SEARCH_SPACE_SIZE, *data, node);
             }
             else
             {
@@ -898,14 +909,22 @@ class GraphContractor
                     }
                     else
                     {
-                        inserted_edges.emplace_back(source, target, path_distance,
+                        inserted_edges.emplace_back(source,
+                                                    target,
+                                                    path_distance,
                                                     out_data.originalEdges + in_data.originalEdges,
-                                                    node, SHORTCUT_ARC, FORWARD_DIRECTION_ENABLED,
+                                                    node,
+                                                    SHORTCUT_ARC,
+                                                    FORWARD_DIRECTION_ENABLED,
                                                     REVERSE_DIRECTION_DISABLED);
 
-                        inserted_edges.emplace_back(target, source, path_distance,
+                        inserted_edges.emplace_back(target,
+                                                    source,
+                                                    path_distance,
                                                     out_data.originalEdges + in_data.originalEdges,
-                                                    node, SHORTCUT_ARC, FORWARD_DIRECTION_DISABLED,
+                                                    node,
+                                                    SHORTCUT_ARC,
+                                                    FORWARD_DIRECTION_DISABLED,
                                                     REVERSE_DIRECTION_ENABLED);
                     }
                 }

include/engine/api/base_api.hpp

@@ -37,11 +37,10 @@ class BaseAPI
         waypoints.values[0] = MakeWaypoint(segment_end_coordinates.front().source_phantom);
 
         auto out_iter = std::next(waypoints.values.begin());
-        boost::range::transform(segment_end_coordinates, out_iter,
-                                [this](const PhantomNodes &phantom_pair)
-                                {
-                                    return MakeWaypoint(phantom_pair.target_phantom);
-                                });
+        boost::range::transform(
+            segment_end_coordinates, out_iter, [this](const PhantomNodes &phantom_pair) {
+                return MakeWaypoint(phantom_pair.target_phantom);
+            });
         return waypoints;
     }
 
@@ -49,7 +48,8 @@ class BaseAPI
     //  protected:
     util::json::Object MakeWaypoint(const PhantomNode &phantom) const
     {
-        return json::makeWaypoint(phantom.location, facade.GetNameForID(phantom.name_id),
+        return json::makeWaypoint(phantom.location,
+                                  facade.GetNameForID(phantom.name_id),
                                   Hint{phantom, facade.GetCheckSum()});
     }
 

include/engine/api/base_parameters.hpp

@@ -28,14 +28,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ENGINE_API_BASE_PARAMETERS_HPP
 #define ENGINE_API_BASE_PARAMETERS_HPP
 
-#include "engine/hint.hpp"
 #include "engine/bearing.hpp"
+#include "engine/hint.hpp"
 #include "util/coordinate.hpp"
 
 #include <boost/optional.hpp>
 
-#include <vector>
 #include <algorithm>
+#include <vector>
 
 namespace osrm
 {
@@ -72,9 +72,9 @@ struct BaseParameters
         return (hints.empty() || hints.size() == coordinates.size()) &&
                (bearings.empty() || bearings.size() == coordinates.size()) &&
                (radiuses.empty() || radiuses.size() == coordinates.size()) &&
-               std::all_of(bearings.begin(), bearings.end(),
-                           [](const boost::optional<Bearing> bearing_and_range)
-                           {
+               std::all_of(bearings.begin(),
+                           bearings.end(),
+                           [](const boost::optional<Bearing> bearing_and_range) {
                                if (bearing_and_range)
                                {
                                    return bearing_and_range->IsValid();

include/engine/api/json_factory.hpp

@@ -3,12 +3,12 @@
 
 #include "extractor/guidance/turn_instruction.hpp"
 #include "extractor/travel_mode.hpp"
-#include "engine/polyline_compressor.hpp"
+#include "engine/guidance/leg_geometry.hpp"
+#include "engine/guidance/route.hpp"
+#include "engine/guidance/route_leg.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "engine/guidance/step_maneuver.hpp"
-#include "engine/guidance/route_leg.hpp"
-#include "engine/guidance/route.hpp"
-#include "engine/guidance/leg_geometry.hpp"
+#include "engine/polyline_compressor.hpp"
 #include "util/coordinate.hpp"
 #include "util/json_container.hpp"
 
@@ -57,7 +57,8 @@ util::json::Object makeGeoJSONGeometry(ForwardIter begin, ForwardIter end)
     {
         geojson.values["type"] = "LineString";
         util::json::Array coordinates;
-        std::transform(begin, end, std::back_inserter(coordinates.values), &detail::coordinateToLonLat);
+        std::transform(
+            begin, end, std::back_inserter(coordinates.values), &detail::coordinateToLonLat);
         geojson.values["coordinates"] = std::move(coordinates);
     }
     else if (num_coordinates > 0)
@@ -85,7 +86,8 @@ makeWaypoint(const util::Coordinate location, std::string name, const Hint &hint
 util::json::Object makeRouteLeg(guidance::RouteLeg leg, util::json::Array steps);
 
 util::json::Array makeRouteLegs(std::vector<guidance::RouteLeg> legs,
-                                std::vector<util::json::Value> step_geometries);
+                                std::vector<util::json::Value> step_geometries,
+                                std::vector<util::json::Object> annotations);
 }
 }
 } // namespace engine

include/engine/api/match_api.hpp

@@ -1,8 +1,8 @@
 #ifndef ENGINE_API_MATCH_HPP
 #define ENGINE_API_MATCH_HPP
 
-#include "engine/api/route_api.hpp"
 #include "engine/api/match_parameters.hpp"
+#include "engine/api/route_api.hpp"
 
 #include "engine/datafacade/datafacade_base.hpp"
 

include/engine/api/nearest_api.hpp

@@ -34,10 +34,10 @@ class NearestAPI final : public BaseAPI
 
         util::json::Array waypoints;
         waypoints.values.resize(phantom_nodes.front().size());
-        std::transform(phantom_nodes.front().begin(), phantom_nodes.front().end(),
+        std::transform(phantom_nodes.front().begin(),
+                       phantom_nodes.front().end(),
                        waypoints.values.begin(),
-                       [this](const PhantomNodeWithDistance &phantom_with_distance)
-                       {
+                       [this](const PhantomNodeWithDistance &phantom_with_distance) {
                            auto waypoint = MakeWaypoint(phantom_with_distance.phantom_node);
                            waypoint.values["distance"] = phantom_with_distance.distance;
                            return waypoint;

include/engine/api/route_api.hpp

@@ -42,14 +42,16 @@ class RouteAPI : public BaseAPI
         auto number_of_routes = raw_route.has_alternative() ? 2UL : 1UL;
         util::json::Array routes;
         routes.values.resize(number_of_routes);
-        routes.values[0] =
-            MakeRoute(raw_route.segment_end_coordinates, raw_route.unpacked_path_segments,
-                      raw_route.source_traversed_in_reverse, raw_route.target_traversed_in_reverse);
+        routes.values[0] = MakeRoute(raw_route.segment_end_coordinates,
+                                     raw_route.unpacked_path_segments,
+                                     raw_route.source_traversed_in_reverse,
+                                     raw_route.target_traversed_in_reverse);
         if (raw_route.has_alternative())
         {
             std::vector<std::vector<PathData>> wrapped_leg(1);
             wrapped_leg.front() = std::move(raw_route.unpacked_alternative);
-            routes.values[1] = MakeRoute(raw_route.segment_end_coordinates, wrapped_leg,
+            routes.values[1] = MakeRoute(raw_route.segment_end_coordinates,
+                                         wrapped_leg,
                                          raw_route.alt_source_traversed_in_reverse,
                                          raw_route.alt_target_traversed_in_reverse);
         }
@@ -93,14 +95,23 @@ class RouteAPI : public BaseAPI
 
             auto leg_geometry = guidance::assembleGeometry(
                 BaseAPI::facade, path_data, phantoms.source_phantom, phantoms.target_phantom);
-            auto leg = guidance::assembleLeg(facade, path_data, leg_geometry, phantoms.source_phantom,
-                                             phantoms.target_phantom, reversed_target, parameters.steps);
+            auto leg = guidance::assembleLeg(facade,
+                                             path_data,
+                                             leg_geometry,
+                                             phantoms.source_phantom,
+                                             phantoms.target_phantom,
+                                             reversed_target,
+                                             parameters.steps);
 
             if (parameters.steps)
             {
-                auto steps = guidance::assembleSteps(
-                    BaseAPI::facade, path_data, leg_geometry, phantoms.source_phantom,
-                    phantoms.target_phantom, reversed_source, reversed_target);
+                auto steps = guidance::assembleSteps(BaseAPI::facade,
+                                                     path_data,
+                                                     leg_geometry,
+                                                     phantoms.source_phantom,
+                                                     phantoms.target_phantom,
+                                                     reversed_source,
+                                                     reversed_target);
 
                 /* Perform step-based post-processing.
                  *
@@ -133,7 +144,8 @@ class RouteAPI : public BaseAPI
                 guidance::trimShortSegments(steps, leg_geometry);
                 leg.steps = guidance::postProcess(std::move(steps));
                 leg.steps = guidance::collapseTurns(std::move(leg.steps));
-                leg.steps = guidance::assignRelativeLocations(std::move(leg.steps), leg_geometry,
+                leg.steps = guidance::assignRelativeLocations(std::move(leg.steps),
+                                                              leg_geometry,
                                                               phantoms.source_phantom,
                                                               phantoms.target_phantom);
                 leg_geometry = guidance::resyncGeometry(std::move(leg_geometry), leg.steps);
@@ -161,7 +173,9 @@ class RouteAPI : public BaseAPI
         {
             auto &leg_geometry = leg_geometries[idx];
             std::transform(
-                legs[idx].steps.begin(), legs[idx].steps.end(), std::back_inserter(step_geometries),
+                legs[idx].steps.begin(),
+                legs[idx].steps.end(),
+                std::back_inserter(step_geometries),
                 [this, &leg_geometry](const guidance::RouteStep &step) {
                     if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
                     {
@@ -176,32 +190,42 @@ class RouteAPI : public BaseAPI
                 });
         }
 
-        auto result = json::makeRoute(route,
-                               json::makeRouteLegs(std::move(legs), std::move(step_geometries)),
-                               std::move(json_overview));
+        std::vector<util::json::Object> annotations;
 
-        if (parameters.annotation)
+        if (parameters.annotations)
         {
-            util::json::Array durations;
-            util::json::Array distances;
             for (const auto idx : util::irange<std::size_t>(0UL, leg_geometries.size()))
             {
+                util::json::Array durations;
+                util::json::Array distances;
+                util::json::Array nodes;
                 auto &leg_geometry = leg_geometries[idx];
-                std::for_each(leg_geometry.annotations.begin(),
-                              leg_geometry.annotations.end(),
-                              [this, &durations, &distances](const guidance::LegGeometry::Annotation &step) {
-                                  durations.values.push_back(step.duration);
-                                  distances.values.push_back(step.distance);
+                std::for_each(
+                    leg_geometry.annotations.begin(),
+                    leg_geometry.annotations.end(),
+                    [this, &durations, &distances](const guidance::LegGeometry::Annotation &step) {
+                        durations.values.push_back(step.duration);
+                        distances.values.push_back(step.distance);
+                    });
+                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));
                               });
+                util::json::Object annotation;
+                annotation.values["distance"] = std::move(distances);
+                annotation.values["duration"] = std::move(durations);
+                annotation.values["nodes"] = std::move(nodes);
+                annotations.push_back(std::move(annotation));
             }
-
-            util::json::Object details;
-            details.values["distance"] = std::move(distances);
-            details.values["duration"] = std::move(durations);
-
-            result.values["annotation"] = std::move(details);
         }
 
+        auto result = json::makeRoute(route,
+                                      json::makeRouteLegs(std::move(legs),
+                                                          std::move(step_geometries),
+                                                          std::move(annotations)),
+                                      std::move(json_overview));
+
         return result;
     }
 

include/engine/api/route_parameters.hpp

@@ -72,20 +72,20 @@ struct RouteParameters : public BaseParameters
     template <typename... Args>
     RouteParameters(const bool steps_,
                     const bool alternatives_,
-                    const bool annotation_,
+                    const bool annotations_,
                     const GeometriesType geometries_,
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
                     Args... args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          annotation{annotation_}, geometries{geometries_}, overview{overview_},
+          annotations{annotations_}, geometries{geometries_}, overview{overview_},
           continue_straight{continue_straight_}
     {
     }
 
     bool steps = false;
     bool alternatives = false;
-    bool annotation = false;
+    bool annotations = false;
     GeometriesType geometries = GeometriesType::Polyline;
     OverviewType overview = OverviewType::Simplified;
     boost::optional<bool> continue_straight;

include/engine/api/table_api.hpp

@@ -2,15 +2,15 @@
 #define ENGINE_API_TABLE_HPP
 
 #include "engine/api/base_api.hpp"
-#include "engine/api/table_parameters.hpp"
 #include "engine/api/json_factory.hpp"
+#include "engine/api/table_parameters.hpp"
 
 #include "engine/datafacade/datafacade_base.hpp"
 
-#include "engine/guidance/assemble_leg.hpp"
-#include "engine/guidance/assemble_route.hpp"
 #include "engine/guidance/assemble_geometry.hpp"
+#include "engine/guidance/assemble_leg.hpp"
 #include "engine/guidance/assemble_overview.hpp"
+#include "engine/guidance/assemble_route.hpp"
 #include "engine/guidance/assemble_steps.hpp"
 
 #include "engine/internal_route_result.hpp"
@@ -78,11 +78,10 @@ class TableAPI final : public BaseAPI
         json_waypoints.values.reserve(phantoms.size());
         BOOST_ASSERT(phantoms.size() == parameters.coordinates.size());
 
-        boost::range::transform(phantoms, std::back_inserter(json_waypoints.values),
-                                [this](const PhantomNode &phantom)
-                                {
-                                    return BaseAPI::MakeWaypoint(phantom);
-                                });
+        boost::range::transform(
+            phantoms,
+            std::back_inserter(json_waypoints.values),
+            [this](const PhantomNode &phantom) { return BaseAPI::MakeWaypoint(phantom); });
         return json_waypoints;
     }
 
@@ -91,9 +90,9 @@ class TableAPI final : public BaseAPI
     {
         util::json::Array json_waypoints;
         json_waypoints.values.reserve(indices.size());
-        boost::range::transform(indices, std::back_inserter(json_waypoints.values),
-                                [this, phantoms](const std::size_t idx)
-                                {
+        boost::range::transform(indices,
+                                std::back_inserter(json_waypoints.values),
+                                [this, phantoms](const std::size_t idx) {
                                     BOOST_ASSERT(idx < phantoms.size());
                                     return BaseAPI::MakeWaypoint(phantoms[idx]);
                                 });
@@ -111,9 +110,10 @@ class TableAPI final : public BaseAPI
             auto row_begin_iterator = values.begin() + (row * number_of_columns);
             auto row_end_iterator = values.begin() + ((row + 1) * number_of_columns);
             json_row.values.resize(number_of_columns);
-            std::transform(row_begin_iterator, row_end_iterator, json_row.values.begin(),
-                           [](const EdgeWeight duration)
-                           {
+            std::transform(row_begin_iterator,
+                           row_end_iterator,
+                           json_row.values.begin(),
+                           [](const EdgeWeight duration) {
                                if (duration == INVALID_EDGE_WEIGHT)
                                {
                                    return util::json::Value(util::json::Null());

include/engine/api/table_parameters.hpp

@@ -89,10 +89,7 @@ struct TableParameters : public BaseParameters
             return false;
 
         // 3/ 0 <= index < len(locations)
-        const auto not_in_range = [this](const std::size_t x)
-        {
-            return x >= coordinates.size();
-        };
+        const auto not_in_range = [this](const std::size_t x) { return x >= coordinates.size(); };
 
         if (std::any_of(begin(sources), end(sources), not_in_range))
             return false;

include/engine/api/trip_api.hpp

@@ -79,8 +79,7 @@ class TripAPI final : public RouteAPI
         std::vector<TripIndex> input_idx_to_trip_idx(parameters.coordinates.size());
         for (auto sub_trip_index : util::irange<unsigned>(0u, sub_trips.size()))
         {
-            for (auto point_index :
-                 util::irange<unsigned>(0u, sub_trips[sub_trip_index].size()))
+            for (auto point_index : util::irange<unsigned>(0u, sub_trips[sub_trip_index].size()))
             {
                 input_idx_to_trip_idx[sub_trips[sub_trip_index][point_index]] =
                     TripIndex{sub_trip_index, point_index};

include/engine/base64.hpp

@@ -1,18 +1,18 @@
 #ifndef OSRM_BASE64_HPP
 #define OSRM_BASE64_HPP
 
-#include <string>
-#include <vector>
 #include <iterator>
+#include <string>
 #include <type_traits>
+#include <vector>
 
-#include <cstddef>
 #include <climits>
+#include <cstddef>
 
-#include <boost/archive/iterators/binary_from_base64.hpp>
-#include <boost/archive/iterators/base64_from_binary.hpp>
-#include <boost/archive/iterators/transform_width.hpp>
 #include <boost/algorithm/string/trim.hpp>
+#include <boost/archive/iterators/base64_from_binary.hpp>
+#include <boost/archive/iterators/binary_from_base64.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
 #include <boost/range/algorithm/copy.hpp>
 
 namespace osrm

include/engine/datafacade/datafacade_base.hpp

@@ -4,10 +4,10 @@
 // Exposes all data access interfaces to the algorithms via base class ptr
 
 #include "contractor/query_edge.hpp"
-#include "engine/phantom_node.hpp"
 #include "extractor/edge_based_node.hpp"
 #include "extractor/external_memory_node.hpp"
 #include "extractor/guidance/turn_instruction.hpp"
+#include "engine/phantom_node.hpp"
 #include "util/exception.hpp"
 #include "util/guidance/bearing_class.hpp"
 #include "util/guidance/entry_class.hpp"
@@ -67,6 +67,7 @@ class BaseDataFacade
 
     // node and edge information access
     virtual util::Coordinate GetCoordinateOfNode(const unsigned id) const = 0;
+    virtual OSMNodeID GetOSMNodeIDOfNode(const unsigned id) const = 0;
 
     virtual unsigned GetGeometryIndexForEdgeID(const unsigned id) const = 0;
 
@@ -115,14 +116,15 @@ class BaseDataFacade
                         const int bearing,
                         const int bearing_range) const = 0;
     virtual std::vector<PhantomNodeWithDistance>
-    NearestPhantomNodes(const util::Coordinate input_coordinate, const unsigned max_results) const = 0;
+    NearestPhantomNodes(const util::Coordinate input_coordinate,
+                        const unsigned max_results) const = 0;
     virtual std::vector<PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate input_coordinate,
                         const unsigned max_results,
                         const double max_distance) const = 0;
 
-    virtual std::pair<PhantomNode, PhantomNode>
-    NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate) const = 0;
+    virtual std::pair<PhantomNode, PhantomNode> NearestPhantomNodeWithAlternativeFromBigComponent(
+        const util::Coordinate input_coordinate) const = 0;
     virtual std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
                                                       const double max_distance) const = 0;
@@ -131,8 +133,10 @@ class BaseDataFacade
                                                       const double max_distance,
                                                       const int bearing,
                                                       const int bearing_range) const = 0;
-    virtual std::pair<PhantomNode, PhantomNode> NearestPhantomNodeWithAlternativeFromBigComponent(
-        const util::Coordinate input_coordinate, const int bearing, const int bearing_range) const = 0;
+    virtual std::pair<PhantomNode, PhantomNode>
+    NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
+                                                      const int bearing,
+                                                      const int bearing_range) const = 0;
 
     virtual unsigned GetCheckSum() const = 0;
 
@@ -142,6 +146,10 @@ class BaseDataFacade
 
     virtual std::string GetNameForID(const unsigned name_id) const = 0;
 
+    virtual std::string GetPronunciationForID(const unsigned name_id) const = 0;
+
+    virtual std::string GetDestinationsForID(const unsigned name_id) const = 0;
+
     virtual std::size_t GetCoreSize() const = 0;
 
     virtual std::string GetTimestamp() const = 0;

include/engine/datafacade/internal_datafacade.hpp

@@ -9,14 +9,15 @@
 #include "util/guidance/bearing_class.hpp"
 #include "util/guidance/entry_class.hpp"
 
-#include "engine/geospatial_query.hpp"
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/original_edge_data.hpp"
 #include "extractor/profile_properties.hpp"
 #include "extractor/query_node.hpp"
 #include "storage/storage_config.hpp"
+#include "engine/geospatial_query.hpp"
 #include "util/graph_loader.hpp"
 #include "util/io.hpp"
+#include "util/packed_vector.hpp"
 #include "util/range_table.hpp"
 #include "util/rectangle.hpp"
 #include "util/shared_memory_vector_wrapper.hpp"
@@ -73,6 +74,7 @@ class InternalDataFacade final : public BaseDataFacade
     std::string m_timestamp;
 
     util::ShM<util::Coordinate, false>::vector m_coordinate_list;
+    util::PackedVector<OSMNodeID, false> m_osmnodeid_list;
     util::ShM<NodeID, false>::vector m_via_node_list;
     util::ShM<unsigned, false>::vector m_name_ID_list;
     util::ShM<extractor::guidance::TurnInstruction, false>::vector m_turn_instruction_list;
@@ -156,10 +158,12 @@ class InternalDataFacade final : public BaseDataFacade
         unsigned number_of_coordinates = 0;
         nodes_input_stream.read((char *)&number_of_coordinates, sizeof(unsigned));
         m_coordinate_list.resize(number_of_coordinates);
+        m_osmnodeid_list.reserve(number_of_coordinates);
         for (unsigned i = 0; i < number_of_coordinates; ++i)
         {
             nodes_input_stream.read((char *)&current_node, sizeof(extractor::QueryNode));
             m_coordinate_list[i] = util::Coordinate(current_node.lon, current_node.lat);
+            m_osmnodeid_list.push_back(current_node.node_id);
             BOOST_ASSERT(m_coordinate_list[i].IsValid());
         }
 
@@ -312,11 +316,12 @@ class InternalDataFacade final : public BaseDataFacade
             util::SimpleLogger().Write(logINFO) << "Loading Bearing Class IDs";
             std::vector<BearingClassID> bearing_class_id;
             if (!util::deserializeVector(intersection_stream, bearing_class_id))
-                throw util::exception("Reading from " + intersection_class_file.string() + " failed.");
+                throw util::exception("Reading from " + intersection_class_file.string() +
+                                      " failed.");
 
             m_bearing_class_id_table.resize(bearing_class_id.size());
-            std::copy(bearing_class_id.begin(), bearing_class_id.end(),
-                      &m_bearing_class_id_table[0]);
+            std::copy(
+                bearing_class_id.begin(), bearing_class_id.end(), &m_bearing_class_id_table[0]);
         }
         {
             util::SimpleLogger().Write(logINFO) << "Loading Bearing Classes";
@@ -330,13 +335,15 @@ class InternalDataFacade final : public BaseDataFacade
             intersection_stream.read(reinterpret_cast<char *>(&m_bearing_values_table[0]),
                                      sizeof(m_bearing_values_table[0]) * num_bearings);
             if (!static_cast<bool>(intersection_stream))
-                throw util::exception("Reading from " + intersection_class_file.string() + " failed.");
+                throw util::exception("Reading from " + intersection_class_file.string() +
+                                      " failed.");
         }
         {
             util::SimpleLogger().Write(logINFO) << "Loading Entry Classes";
             std::vector<util::guidance::EntryClass> entry_classes;
             if (!util::deserializeVector(intersection_stream, entry_classes))
-                throw util::exception("Reading from " + intersection_class_file.string() + " failed.");
+                throw util::exception("Reading from " + intersection_class_file.string() +
+                                      " failed.");
 
             m_entry_class_table.resize(entry_classes.size());
             std::copy(entry_classes.begin(), entry_classes.end(), &m_entry_class_table[0]);
@@ -435,6 +442,11 @@ class InternalDataFacade final : public BaseDataFacade
         return m_coordinate_list[id];
     }
 
+    OSMNodeID GetOSMNodeIDOfNode(const unsigned id) const override final
+    {
+        return m_osmnodeid_list.at(id);
+    }
+
     extractor::guidance::TurnInstruction
     GetTurnInstructionForEdgeID(const unsigned id) const override final
     {
@@ -450,8 +462,8 @@ class InternalDataFacade final : public BaseDataFacade
                                          const util::Coordinate north_east) const override final
     {
         BOOST_ASSERT(m_geospatial_query.get());
-        const util::RectangleInt2D bbox{south_west.lon, north_east.lon, south_west.lat,
-                                        north_east.lat};
+        const util::RectangleInt2D bbox{
+            south_west.lon, north_east.lon, south_west.lat, north_east.lat};
         return m_geospatial_query->Search(bbox);
     }
 
@@ -472,8 +484,8 @@ class InternalDataFacade final : public BaseDataFacade
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
-        return m_geospatial_query->NearestPhantomNodesInRange(input_coordinate, max_distance,
-                                                              bearing, bearing_range);
+        return m_geospatial_query->NearestPhantomNodesInRange(
+            input_coordinate, max_distance, bearing, bearing_range);
     }
 
     std::vector<PhantomNodeWithDistance>
@@ -503,8 +515,8 @@ class InternalDataFacade final : public BaseDataFacade
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
-        return m_geospatial_query->NearestPhantomNodes(input_coordinate, max_results, bearing,
-                                                       bearing_range);
+        return m_geospatial_query->NearestPhantomNodes(
+            input_coordinate, max_results, bearing, bearing_range);
     }
 
     std::vector<PhantomNodeWithDistance>
@@ -516,8 +528,8 @@ class InternalDataFacade final : public BaseDataFacade
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
-        return m_geospatial_query->NearestPhantomNodes(input_coordinate, max_results, max_distance,
-                                                       bearing, bearing_range);
+        return m_geospatial_query->NearestPhantomNodes(
+            input_coordinate, max_results, max_distance, bearing, bearing_range);
     }
 
     std::pair<PhantomNode, PhantomNode> NearestPhantomNodeWithAlternativeFromBigComponent(
@@ -582,11 +594,30 @@ class InternalDataFacade final : public BaseDataFacade
         {
             result.resize(range.back() - range.front() + 1);
             std::copy(m_names_char_list.begin() + range.front(),
-                      m_names_char_list.begin() + range.back() + 1, result.begin());
+                      m_names_char_list.begin() + range.back() + 1,
+                      result.begin());
         }
         return result;
     }
 
+    std::string GetPronunciationForID(const unsigned name_id) const override final
+    {
+        // We store the pronounciation after the name and destination of a street.
+        // We do this to get around the street length limit of 255 which would hit
+        // if we concatenate these. Order (see extractor_callbacks):
+        // name (0), destination (1), pronunciation (2)
+        return GetNameForID(name_id + 2);
+    }
+
+    std::string GetDestinationsForID(const unsigned name_id) const override final
+    {
+        // We store the destination after the name of a street.
+        // We do this to get around the street length limit of 255 which would hit
+        // if we concatenate these. Order (see extractor_callbacks):
+        // name (0), destination (1), pronunciation (2)
+        return GetNameForID(name_id + 1);
+    }
+
     virtual unsigned GetGeometryIndexForEdgeID(const unsigned id) const override final
     {
         return m_via_node_list.at(id);
@@ -614,7 +645,8 @@ class InternalDataFacade final : public BaseDataFacade
 
         result_nodes.clear();
         result_nodes.reserve(end - begin);
-        std::for_each(m_geometry_list.begin() + begin, m_geometry_list.begin() + end,
+        std::for_each(m_geometry_list.begin() + begin,
+                      m_geometry_list.begin() + end,
                       [&](const osrm::extractor::CompressedEdgeContainer::CompressedEdge &edge) {
                           result_nodes.emplace_back(edge.node_id);
                       });
@@ -629,7 +661,8 @@ class InternalDataFacade final : public BaseDataFacade
 
         result_weights.clear();
         result_weights.reserve(end - begin);
-        std::for_each(m_geometry_list.begin() + begin, m_geometry_list.begin() + end,
+        std::for_each(m_geometry_list.begin() + begin,
+                      m_geometry_list.begin() + end,
                       [&](const osrm::extractor::CompressedEdgeContainer::CompressedEdge &edge) {
                           result_weights.emplace_back(edge.weight);
                       });
@@ -658,7 +691,8 @@ class InternalDataFacade final : public BaseDataFacade
         else
         {
             std::for_each(
-                m_datasource_list.begin() + begin, m_datasource_list.begin() + end,
+                m_datasource_list.begin() + begin,
+                m_datasource_list.begin() + end,
                 [&](const uint8_t &datasource_id) { result_datasources.push_back(datasource_id); });
         }
     }
@@ -691,7 +725,8 @@ class InternalDataFacade final : public BaseDataFacade
         util::guidance::BearingClass result;
 
         for (auto itr = m_bearing_values_table.begin() + range.front();
-             itr != m_bearing_values_table.begin() + range.back() + 1; ++itr)
+             itr != m_bearing_values_table.begin() + range.back() + 1;
+             ++itr)
             result.add(*itr);
 
         return result;

include/engine/datafacade/shared_datafacade.hpp

@@ -3,9 +3,9 @@
 
 // implements all data storage when shared memory _IS_ used
 
-#include "engine/datafacade/datafacade_base.hpp"
 #include "storage/shared_datatype.hpp"
 #include "storage/shared_memory.hpp"
+#include "engine/datafacade/datafacade_base.hpp"
 
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/guidance/turn_instruction.hpp"
@@ -76,6 +76,7 @@ class SharedDataFacade final : public BaseDataFacade
     extractor::ProfileProperties *m_profile_properties;
 
     util::ShM<util::Coordinate, true>::vector m_coordinate_list;
+    util::PackedVector<OSMNodeID, true> m_osmnodeid_list;
     util::ShM<NodeID, true>::vector m_via_node_list;
     util::ShM<unsigned, true>::vector m_name_ID_list;
     util::ShM<extractor::guidance::TurnInstruction, true>::vector m_turn_instruction_list;
@@ -138,9 +139,11 @@ class SharedDataFacade final : public BaseDataFacade
 
         auto tree_ptr = data_layout->GetBlockPtr<RTreeNode>(
             shared_memory, storage::SharedDataLayout::R_SEARCH_TREE);
-        m_static_rtree.reset(new SharedRTree(
-            tree_ptr, data_layout->num_entries[storage::SharedDataLayout::R_SEARCH_TREE],
-            file_index_path, m_coordinate_list));
+        m_static_rtree.reset(
+            new SharedRTree(tree_ptr,
+                            data_layout->num_entries[storage::SharedDataLayout::R_SEARCH_TREE],
+                            file_index_path,
+                            m_coordinate_list));
         m_geospatial_query.reset(
             new SharedGeospatialQuery(*m_static_rtree, m_coordinate_list, *this));
     }
@@ -164,9 +167,18 @@ class SharedDataFacade final : public BaseDataFacade
     {
         auto coordinate_list_ptr = data_layout->GetBlockPtr<util::Coordinate>(
             shared_memory, storage::SharedDataLayout::COORDINATE_LIST);
-        m_coordinate_list.reset(coordinate_list_ptr,
+        m_coordinate_list.reset(
+            coordinate_list_ptr,
             data_layout->num_entries[storage::SharedDataLayout::COORDINATE_LIST]);
 
+        auto osmnodeid_list_ptr = data_layout->GetBlockPtr<OSMNodeID>(
+            shared_memory, storage::SharedDataLayout::OSM_NODE_ID_LIST);
+        m_osmnodeid_list.reset(
+            osmnodeid_list_ptr,
+            data_layout->num_entries[storage::SharedDataLayout::OSM_NODE_ID_LIST]);
+        m_osmnodeid_list.set_number_of_entries(util::PackedVectorCapacity(
+            data_layout->num_entries[storage::SharedDataLayout::OSM_NODE_ID_LIST]));
+
         auto travel_mode_list_ptr = data_layout->GetBlockPtr<extractor::TravelMode>(
             shared_memory, storage::SharedDataLayout::TRAVEL_MODE);
         util::ShM<extractor::TravelMode, true>::vector travel_mode_list(
@@ -332,8 +344,8 @@ class SharedDataFacade final : public BaseDataFacade
                 "No shared memory blocks found, have you forgotten to run osrm-datastore?");
         }
         data_timestamp_ptr = static_cast<storage::SharedDataTimestamp *>(
-            storage::makeSharedMemory(storage::CURRENT_REGIONS,
-                                      sizeof(storage::SharedDataTimestamp), false, false)
+            storage::makeSharedMemory(
+                storage::CURRENT_REGIONS, sizeof(storage::SharedDataTimestamp), false, false)
                 ->Ptr());
         CURRENT_LAYOUT = storage::LAYOUT_NONE;
         CURRENT_DATA = storage::DATA_NONE;
@@ -468,6 +480,11 @@ class SharedDataFacade final : public BaseDataFacade
         return m_coordinate_list[id];
     }
 
+    OSMNodeID GetOSMNodeIDOfNode(const unsigned id) const override final
+    {
+        return m_osmnodeid_list.at(id);
+    }
+
     virtual void GetUncompressedGeometry(const EdgeID id,
                                          std::vector<NodeID> &result_nodes) const override final
     {
@@ -476,7 +493,8 @@ class SharedDataFacade final : public BaseDataFacade
 
         result_nodes.clear();
         result_nodes.reserve(end - begin);
-        std::for_each(m_geometry_list.begin() + begin, m_geometry_list.begin() + end,
+        std::for_each(m_geometry_list.begin() + begin,
+                      m_geometry_list.begin() + end,
                       [&](const osrm::extractor::CompressedEdgeContainer::CompressedEdge &edge) {
                           result_nodes.emplace_back(edge.node_id);
                       });
@@ -491,7 +509,8 @@ class SharedDataFacade final : public BaseDataFacade
 
         result_weights.clear();
         result_weights.reserve(end - begin);
-        std::for_each(m_geometry_list.begin() + begin, m_geometry_list.begin() + end,
+        std::for_each(m_geometry_list.begin() + begin,
+                      m_geometry_list.begin() + end,
                       [&](const osrm::extractor::CompressedEdgeContainer::CompressedEdge &edge) {
                           result_weights.emplace_back(edge.weight);
                       });
@@ -517,8 +536,8 @@ class SharedDataFacade final : public BaseDataFacade
                                          const util::Coordinate north_east) const override final
     {
         BOOST_ASSERT(m_geospatial_query.get());
-        const util::RectangleInt2D bbox{south_west.lon, north_east.lon, south_west.lat,
-                                        north_east.lat};
+        const util::RectangleInt2D bbox{
+            south_west.lon, north_east.lon, south_west.lat, north_east.lat};
         return m_geospatial_query->Search(bbox);
     }
 
@@ -539,8 +558,8 @@ class SharedDataFacade final : public BaseDataFacade
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
-        return m_geospatial_query->NearestPhantomNodesInRange(input_coordinate, max_distance,
-                                                              bearing, bearing_range);
+        return m_geospatial_query->NearestPhantomNodesInRange(
+            input_coordinate, max_distance, bearing, bearing_range);
     }
 
     std::vector<PhantomNodeWithDistance>
@@ -570,8 +589,8 @@ class SharedDataFacade final : public BaseDataFacade
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
-        return m_geospatial_query->NearestPhantomNodes(input_coordinate, max_results, bearing,
-                                                       bearing_range);
+        return m_geospatial_query->NearestPhantomNodes(
+            input_coordinate, max_results, bearing, bearing_range);
     }
 
     std::vector<PhantomNodeWithDistance>
@@ -583,8 +602,8 @@ class SharedDataFacade final : public BaseDataFacade
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
-        return m_geospatial_query->NearestPhantomNodes(input_coordinate, max_results, max_distance,
-                                                       bearing, bearing_range);
+        return m_geospatial_query->NearestPhantomNodes(
+            input_coordinate, max_results, max_distance, bearing, bearing_range);
     }
 
     std::pair<PhantomNode, PhantomNode> NearestPhantomNodeWithAlternativeFromBigComponent(
@@ -596,9 +615,8 @@ class SharedDataFacade final : public BaseDataFacade
             input_coordinate);
     }
 
-    std::pair<PhantomNode, PhantomNode>
-    NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                      const double max_distance) const override final
+    std::pair<PhantomNode, PhantomNode> NearestPhantomNodeWithAlternativeFromBigComponent(
+        const util::Coordinate input_coordinate, const double max_distance) const override final
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
@@ -650,11 +668,30 @@ class SharedDataFacade final : public BaseDataFacade
         {
             result.resize(range.back() - range.front() + 1);
             std::copy(m_names_char_list.begin() + range.front(),
-                      m_names_char_list.begin() + range.back() + 1, result.begin());
+                      m_names_char_list.begin() + range.back() + 1,
+                      result.begin());
         }
         return result;
     }
 
+    std::string GetPronunciationForID(const unsigned name_id) const override final
+    {
+        // We store the pronounciation after the name and destination of a street.
+        // We do this to get around the street length limit of 255 which would hit
+        // if we concatenate these. Order (see extractor_callbacks):
+        // name (0), destination (1), pronunciation (2)
+        return GetNameForID(name_id + 2);
+    }
+
+    std::string GetDestinationsForID(const unsigned name_id) const override final
+    {
+        // We store the destination after the name of a street.
+        // We do this to get around the street length limit of 255 which would hit
+        // if we concatenate these. Order (see extractor_callbacks):
+        // name (0), destination (1), pronunciation (2)
+        return GetNameForID(name_id + 1);
+    }
+
     bool IsCoreNode(const NodeID id) const override final
     {
         if (m_is_core_node.size() > 0)
@@ -690,7 +727,8 @@ class SharedDataFacade final : public BaseDataFacade
         else
         {
             std::for_each(
-                m_datasource_list.begin() + begin, m_datasource_list.begin() + end,
+                m_datasource_list.begin() + begin,
+                m_datasource_list.begin() + end,
                 [&](const uint8_t &datasource_id) { result_datasources.push_back(datasource_id); });
         }
     }
@@ -729,7 +767,8 @@ class SharedDataFacade final : public BaseDataFacade
         auto range = m_bearing_ranges_table->GetRange(bearing_class_id);
         util::guidance::BearingClass result;
         for (auto itr = m_bearing_values_table.begin() + range.front();
-             itr != m_bearing_values_table.begin() + range.back() + 1; ++itr)
+             itr != m_bearing_values_table.begin() + range.back() + 1;
+             ++itr)
             result.add(*itr);
         return result;
     }

include/engine/douglas_peucker.hpp

@@ -3,8 +3,8 @@
 
 #include "util/coordinate.hpp"
 
-#include <vector>
 #include <iterator>
+#include <vector>
 
 namespace osrm
 {

include/engine/engine.hpp

@@ -1,13 +1,13 @@
 #ifndef ENGINE_HPP
 #define ENGINE_HPP
 
-#include "engine/status.hpp"
 #include "storage/shared_barriers.hpp"
+#include "engine/status.hpp"
 #include "util/json_container.hpp"
 
 #include <memory>
-#include <unordered_map>
 #include <string>
+#include <unordered_map>
 
 namespace osrm
 {

include/engine/geospatial_query.hpp

@@ -1,11 +1,11 @@
 #ifndef GEOSPATIAL_QUERY_HPP
 #define GEOSPATIAL_QUERY_HPP
 
-#include "util/coordinate_calculation.hpp"
-#include "util/typedefs.hpp"
 #include "engine/phantom_node.hpp"
 #include "util/bearing.hpp"
+#include "util/coordinate_calculation.hpp"
 #include "util/rectangle.hpp"
+#include "util/typedefs.hpp"
 #include "util/web_mercator.hpp"
 
 #include "osrm/coordinate.hpp"
@@ -30,9 +30,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     using CandidateSegment = typename RTreeT::CandidateSegment;
 
   public:
-    GeospatialQuery(RTreeT &rtree_,
-                    const CoordinateList &coordinates_,
-                    DataFacadeT &datafacade_)
+    GeospatialQuery(RTreeT &rtree_, const CoordinateList &coordinates_, DataFacadeT &datafacade_)
         : rtree(rtree_), coordinates(coordinates_), datafacade(datafacade_)
     {
     }
@@ -45,17 +43,14 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     // Returns nearest PhantomNodes in the given bearing range within max_distance.
     // Does not filter by small/big component!
     std::vector<PhantomNodeWithDistance>
-    NearestPhantomNodesInRange(const util::Coordinate input_coordinate, const double max_distance) const
+    NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
+                               const double max_distance) const
     {
         auto results =
             rtree.Nearest(input_coordinate,
-                          [](const CandidateSegment &)
-                          {
-                              return std::make_pair(true, true);
-                          },
+                          [](const CandidateSegment &) { return std::make_pair(true, true); },
                           [this, max_distance, input_coordinate](const std::size_t,
-                                                                 const CandidateSegment &segment)
-                          {
+                                                                 const CandidateSegment &segment) {
                               return CheckSegmentDistance(input_coordinate, segment, max_distance);
                           });
 
@@ -72,13 +67,11 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     {
         auto results = rtree.Nearest(
             input_coordinate,
-            [this, bearing, bearing_range, max_distance](const CandidateSegment &segment)
-            {
+            [this, bearing, bearing_range, max_distance](const CandidateSegment &segment) {
                 return CheckSegmentBearing(segment, bearing, bearing_range);
             },
             [this, max_distance, input_coordinate](const std::size_t,
-                                                   const CandidateSegment &segment)
-            {
+                                                   const CandidateSegment &segment) {
                 return CheckSegmentDistance(input_coordinate, segment, max_distance);
             });
 
@@ -95,12 +88,10 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     {
         auto results =
             rtree.Nearest(input_coordinate,
-                          [this, bearing, bearing_range](const CandidateSegment &segment)
-                          {
+                          [this, bearing, bearing_range](const CandidateSegment &segment) {
                               return CheckSegmentBearing(segment, bearing, bearing_range);
                           },
-                          [max_results](const std::size_t num_results, const CandidateSegment &)
-                          {
+                          [max_results](const std::size_t num_results, const CandidateSegment &) {
                               return num_results >= max_results;
                           });
 
@@ -119,13 +110,11 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     {
         auto results =
             rtree.Nearest(input_coordinate,
-                          [this, bearing, bearing_range](const CandidateSegment &segment)
-                          {
+                          [this, bearing, bearing_range](const CandidateSegment &segment) {
                               return CheckSegmentBearing(segment, bearing, bearing_range);
                           },
                           [this, max_distance, max_results, input_coordinate](
-                              const std::size_t num_results, const CandidateSegment &segment)
-                          {
+                              const std::size_t num_results, const CandidateSegment &segment) {
                               return num_results >= max_results ||
                                      CheckSegmentDistance(input_coordinate, segment, max_distance);
                           });
@@ -140,12 +129,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     {
         auto results =
             rtree.Nearest(input_coordinate,
-                          [](const CandidateSegment &)
-                          {
-                              return std::make_pair(true, true);
-                          },
-                          [max_results](const std::size_t num_results, const CandidateSegment &)
-                          {
+                          [](const CandidateSegment &) { return std::make_pair(true, true); },
+                          [max_results](const std::size_t num_results, const CandidateSegment &) {
                               return num_results >= max_results;
                           });
 
@@ -161,13 +146,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     {
         auto results =
             rtree.Nearest(input_coordinate,
-                          [](const CandidateSegment &)
-                          {
-                              return std::make_pair(true, true);
-                          },
+                          [](const CandidateSegment &) { return std::make_pair(true, true); },
                           [this, max_distance, max_results, input_coordinate](
-                              const std::size_t num_results, const CandidateSegment &segment)
-                          {
+                              const std::size_t num_results, const CandidateSegment &segment) {
                               return num_results >= max_results ||
                                      CheckSegmentDistance(input_coordinate, segment, max_distance);
                           });
@@ -185,8 +166,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         bool has_big_component = false;
         auto results = rtree.Nearest(
             input_coordinate,
-            [&has_big_component, &has_small_component](const CandidateSegment &segment)
-            {
+            [&has_big_component, &has_small_component](const CandidateSegment &segment) {
                 auto use_segment = (!has_small_component ||
                                     (!has_big_component && !segment.data.component.is_tiny));
                 auto use_directions = std::make_pair(use_segment, use_segment);
@@ -196,9 +176,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
 
                 return use_directions;
             },
-            [this, &has_big_component, max_distance,
-             input_coordinate](const std::size_t num_results, const CandidateSegment &segment)
-            {
+            [this, &has_big_component, max_distance, input_coordinate](
+                const std::size_t num_results, const CandidateSegment &segment) {
                 return (num_results > 0 && has_big_component) ||
                        CheckSegmentDistance(input_coordinate, segment, max_distance);
             });
@@ -222,8 +201,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         bool has_big_component = false;
         auto results = rtree.Nearest(
             input_coordinate,
-            [&has_big_component, &has_small_component](const CandidateSegment &segment)
-            {
+            [&has_big_component, &has_small_component](const CandidateSegment &segment) {
                 auto use_segment = (!has_small_component ||
                                     (!has_big_component && !segment.data.component.is_tiny));
                 auto use_directions = std::make_pair(use_segment, use_segment);
@@ -233,8 +211,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
 
                 return use_directions;
             },
-            [&has_big_component](const std::size_t num_results, const CandidateSegment &)
-            {
+            [&has_big_component](const std::size_t num_results, const CandidateSegment &) {
                 return num_results > 0 && has_big_component;
             });
 
@@ -257,9 +234,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         bool has_big_component = false;
         auto results = rtree.Nearest(
             input_coordinate,
-            [this, bearing, bearing_range, &has_big_component,
-             &has_small_component](const CandidateSegment &segment)
-            {
+            [this, bearing, bearing_range, &has_big_component, &has_small_component](
+                const CandidateSegment &segment) {
                 auto use_segment = (!has_small_component ||
                                     (!has_big_component && !segment.data.component.is_tiny));
                 auto use_directions = std::make_pair(use_segment, use_segment);
@@ -276,8 +252,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
 
                 return use_directions;
             },
-            [&has_big_component](const std::size_t num_results, const CandidateSegment &)
-            {
+            [&has_big_component](const std::size_t num_results, const CandidateSegment &) {
                 return num_results > 0 && has_big_component;
             });
 
@@ -303,9 +278,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         bool has_big_component = false;
         auto results = rtree.Nearest(
             input_coordinate,
-            [this, bearing, bearing_range, &has_big_component,
-             &has_small_component](const CandidateSegment &segment)
-            {
+            [this, bearing, bearing_range, &has_big_component, &has_small_component](
+                const CandidateSegment &segment) {
                 auto use_segment = (!has_small_component ||
                                     (!has_big_component && !segment.data.component.is_tiny));
                 auto use_directions = std::make_pair(use_segment, use_segment);
@@ -322,9 +296,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
 
                 return use_directions;
             },
-            [this, &has_big_component, max_distance,
-             input_coordinate](const std::size_t num_results, const CandidateSegment &segment)
-            {
+            [this, &has_big_component, max_distance, input_coordinate](
+                const std::size_t num_results, const CandidateSegment &segment) {
                 return (num_results > 0 && has_big_component) ||
                        CheckSegmentDistance(input_coordinate, segment, max_distance);
             });
@@ -345,9 +318,10 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                      const std::vector<EdgeData> &results) const
     {
         std::vector<PhantomNodeWithDistance> distance_and_phantoms(results.size());
-        std::transform(results.begin(), results.end(), distance_and_phantoms.begin(),
-                       [this, &input_coordinate](const EdgeData &data)
-                       {
+        std::transform(results.begin(),
+                       results.end(),
+                       distance_and_phantoms.begin(),
+                       [this, &input_coordinate](const EdgeData &data) {
                            return MakePhantomNode(input_coordinate, data);
                        });
         return distance_and_phantoms;
@@ -359,9 +333,11 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         util::Coordinate point_on_segment;
         double ratio;
         const auto current_perpendicular_distance =
-            util::coordinate_calculation::perpendicularDistance(
-                coordinates[data.u], coordinates[data.v], input_coordinate,
-                point_on_segment, ratio);
+            util::coordinate_calculation::perpendicularDistance(coordinates[data.u],
+                                                                coordinates[data.v],
+                                                                input_coordinate,
+                                                                point_on_segment,
+                                                                ratio);
 
         // Find the node-based-edge that this belongs to, and directly
         // calculate the forward_weight, forward_offset, reverse_weight, reverse_offset
@@ -390,7 +366,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             BOOST_ASSERT(data.fwd_segment_position < reverse_weight_vector.size());
 
             for (std::size_t i = 0;
-                 i < reverse_weight_vector.size() - data.fwd_segment_position - 1; i++)
+                 i < reverse_weight_vector.size() - data.fwd_segment_position - 1;
+                 i++)
             {
                 reverse_offset += reverse_weight_vector[i];
             }
@@ -408,9 +385,13 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             reverse_weight *= 1.0 - ratio;
         }
 
-        auto transformed = PhantomNodeWithDistance{PhantomNode{data, forward_weight, forward_offset,
-                                                               reverse_weight, reverse_offset,
-                                                               point_on_segment, input_coordinate},
+        auto transformed = PhantomNodeWithDistance{PhantomNode{data,
+                                                               forward_weight,
+                                                               forward_offset,
+                                                               reverse_weight,
+                                                               reverse_offset,
+                                                               point_on_segment,
+                                                               input_coordinate},
                                                    current_perpendicular_distance};
 
         return transformed;
@@ -449,12 +430,12 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                                                  : (forward_edge_bearing + 180);
 
         const bool forward_bearing_valid =
-            util::bearing::CheckInBounds(std::round(forward_edge_bearing), filter_bearing,
-                                         filter_bearing_range) &&
+            util::bearing::CheckInBounds(
+                std::round(forward_edge_bearing), filter_bearing, filter_bearing_range) &&
             segment.data.forward_segment_id.enabled;
         const bool backward_bearing_valid =
-            util::bearing::CheckInBounds(std::round(backward_edge_bearing), filter_bearing,
-                                         filter_bearing_range) &&
+            util::bearing::CheckInBounds(
+                std::round(backward_edge_bearing), filter_bearing, filter_bearing_range) &&
             segment.data.reverse_segment_id.enabled;
         return std::make_pair(forward_bearing_valid, backward_bearing_valid);
     }

include/engine/guidance/assemble_geometry.hpp

@@ -1,18 +1,18 @@
 #ifndef ENGINE_GUIDANCE_ASSEMBLE_GEOMETRY_HPP
 #define ENGINE_GUIDANCE_ASSEMBLE_GEOMETRY_HPP
 
-#include "engine/internal_route_result.hpp"
-#include "engine/phantom_node.hpp"
-#include "engine/guidance/route_step.hpp"
-#include "engine/guidance/leg_geometry.hpp"
-#include "engine/guidance/toolkit.hpp"
-#include "util/coordinate_calculation.hpp"
-#include "util/coordinate.hpp"
 #include "extractor/guidance/turn_instruction.hpp"
 #include "extractor/travel_mode.hpp"
+#include "engine/guidance/leg_geometry.hpp"
+#include "engine/guidance/route_step.hpp"
+#include "engine/guidance/toolkit.hpp"
+#include "engine/internal_route_result.hpp"
+#include "engine/phantom_node.hpp"
+#include "util/coordinate.hpp"
+#include "util/coordinate_calculation.hpp"
 
-#include <vector>
 #include <utility>
+#include <vector>
 
 namespace osrm
 {
@@ -43,6 +43,13 @@ LegGeometry assembleGeometry(const DataFacadeT &facade,
     geometry.segment_offsets.push_back(0);
     geometry.locations.push_back(source_node.location);
 
+    // Need to get the node ID preceding the source phantom node
+    // TODO: check if this was traversed in reverse?
+    std::vector<NodeID> reverse_geometry;
+    facade.GetUncompressedGeometry(source_node.reverse_packed_geometry_id, reverse_geometry);
+    geometry.osm_node_ids.push_back(facade.GetOSMNodeIDOfNode(
+        reverse_geometry[reverse_geometry.size() - source_node.fwd_segment_position - 1]));
+
     auto cumulative_distance = 0.;
     auto current_distance = 0.;
     auto prev_coordinate = geometry.locations.front();
@@ -62,18 +69,28 @@ LegGeometry assembleGeometry(const DataFacadeT &facade,
         }
 
         prev_coordinate = coordinate;
-        geometry.annotations.emplace_back(LegGeometry::Annotation{current_distance, path_point.duration_until_turn / 10.});
+        geometry.annotations.emplace_back(
+            LegGeometry::Annotation{current_distance, path_point.duration_until_turn / 10.});
         geometry.locations.push_back(std::move(coordinate));
+        geometry.osm_node_ids.push_back(facade.GetOSMNodeIDOfNode(path_point.turn_via_node));
     }
     current_distance =
         util::coordinate_calculation::haversineDistance(prev_coordinate, target_node.location);
     cumulative_distance += current_distance;
     // segment leading to the target node
     geometry.segment_distances.push_back(cumulative_distance);
-    geometry.annotations.emplace_back(LegGeometry::Annotation{current_distance, target_node.forward_weight / 10.});
+    geometry.annotations.emplace_back(
+        LegGeometry::Annotation{current_distance, target_node.forward_weight / 10.});
     geometry.segment_offsets.push_back(geometry.locations.size());
     geometry.locations.push_back(target_node.location);
 
+    // Need to get the node ID following the destination phantom node
+    // TODO: check if this was traversed in reverse??
+    std::vector<NodeID> forward_geometry;
+    facade.GetUncompressedGeometry(target_node.forward_packed_geometry_id, forward_geometry);
+    geometry.osm_node_ids.push_back(
+        facade.GetOSMNodeIDOfNode(forward_geometry[target_node.fwd_segment_position]));
+
     BOOST_ASSERT(geometry.segment_distances.size() == geometry.segment_offsets.size() - 1);
     BOOST_ASSERT(geometry.locations.size() > geometry.segment_distances.size());
     BOOST_ASSERT(geometry.annotations.size() == geometry.locations.size() - 1);

include/engine/guidance/assemble_leg.hpp

@@ -35,11 +35,12 @@ struct NamedSegment
 
 template <std::size_t SegmentNumber>
 
-std::array<std::uint32_t, SegmentNumber> summarizeRoute(const std::vector<PathData> &route_data)
+std::array<std::uint32_t, SegmentNumber> summarizeRoute(const std::vector<PathData> &route_data,
+                                                        const PhantomNode &target_node,
+                                                        const bool target_traversed_in_reverse)
 {
     // merges segments with same name id
-    const auto collapse_segments = [](std::vector<NamedSegment> &segments)
-    {
+    const auto collapse_segments = [](std::vector<NamedSegment> &segments) {
         auto out = segments.begin();
         auto end = segments.end();
 
@@ -69,47 +70,48 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const std::vector<PathDa
     std::vector<NamedSegment> segments(route_data.size());
     std::uint32_t index = 0;
     std::transform(
-        route_data.begin(), route_data.end(), segments.begin(), [&index](const PathData &point)
-        {
+        route_data.begin(), route_data.end(), segments.begin(), [&index](const PathData &point) {
             return NamedSegment{point.duration_until_turn, index++, point.name_id};
         });
+    const auto target_duration =
+        target_traversed_in_reverse ? target_node.reverse_weight : target_node.forward_weight;
+    if (target_duration > 1)
+        segments.push_back({target_duration, index++, target_node.name_id});
     // this makes sure that the segment with the lowest position comes first
-    std::sort(segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs)
-              {
-                  return lhs.name_id < rhs.name_id ||
-                         (lhs.name_id == rhs.name_id && lhs.position < rhs.position);
-              });
+    std::sort(
+        segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
+            return lhs.name_id < rhs.name_id ||
+                   (lhs.name_id == rhs.name_id && lhs.position < rhs.position);
+        });
     auto new_end = collapse_segments(segments);
     segments.resize(new_end - segments.begin());
 
     // Filter out segments with an empty name (name_id == 0)
-    new_end = std::remove_if(segments.begin(), segments.end(), [](const NamedSegment &segment)
-              {
-                  return segment.name_id == 0;
-              });
+    new_end = std::remove_if(segments.begin(), segments.end(), [](const NamedSegment &segment) {
+        return segment.name_id == 0;
+    });
     segments.resize(new_end - segments.begin());
 
     // sort descending
-    std::sort(segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs)
-              {
-                  return lhs.duration > rhs.duration ||
-                         (lhs.duration == rhs.duration && lhs.position < rhs.position);
-              });
+    std::sort(
+        segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
+            return lhs.duration > rhs.duration ||
+                   (lhs.duration == rhs.duration && lhs.position < rhs.position);
+        });
 
     // make sure the segments are sorted by position
     segments.resize(std::min(segments.size(), SegmentNumber));
-    std::sort(segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs)
-              {
-                  return lhs.position < rhs.position;
-              });
+    std::sort(
+        segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
+            return lhs.position < rhs.position;
+        });
 
     std::array<std::uint32_t, SegmentNumber> summary;
     std::fill(summary.begin(), summary.end(), 0);
-    std::transform(segments.begin(), segments.end(), summary.begin(),
-                   [](const NamedSegment &segment)
-                   {
-                       return segment.name_id;
-                   });
+    std::transform(segments.begin(),
+                   segments.end(),
+                   summary.begin(),
+                   [](const NamedSegment &segment) { return segment.name_id; });
     return summary;
 }
 }
@@ -126,9 +128,11 @@ inline RouteLeg assembleLeg(const datafacade::BaseDataFacade &facade,
         (target_traversed_in_reverse ? target_node.reverse_weight : target_node.forward_weight) /
         10.;
 
-    auto distance = std::accumulate(leg_geometry.segment_distances.begin(),
-                                    leg_geometry.segment_distances.end(), 0.);
-    auto duration = std::accumulate(route_data.begin(), route_data.end(), 0.,
+    auto distance = std::accumulate(
+        leg_geometry.segment_distances.begin(), leg_geometry.segment_distances.end(), 0.);
+    auto duration = std::accumulate(route_data.begin(),
+                                    route_data.end(),
+                                    0.,
                                     [](const double sum, const PathData &data) {
                                         return sum + data.duration_until_turn;
                                     }) /
@@ -166,14 +170,17 @@ inline RouteLeg assembleLeg(const datafacade::BaseDataFacade &facade,
     std::string summary;
     if (needs_summary)
     {
-        auto summary_array = detail::summarizeRoute<detail::MAX_USED_SEGMENTS>(route_data);
+        auto summary_array = detail::summarizeRoute<detail::MAX_USED_SEGMENTS>(
+            route_data, target_node, target_traversed_in_reverse);
+        if (route_data.empty())
+            summary_array[0] = source_node.name_id;
 
         BOOST_ASSERT(detail::MAX_USED_SEGMENTS > 0);
         BOOST_ASSERT(summary_array.begin() != summary_array.end());
-        summary = std::accumulate(std::next(summary_array.begin()), summary_array.end(),
+        summary = std::accumulate(std::next(summary_array.begin()),
+                                  summary_array.end(),
                                   facade.GetNameForID(summary_array.front()),
-                                  [&facade](std::string previous, const std::uint32_t name_id)
-                                  {
+                                  [&facade](std::string previous, const std::uint32_t name_id) {
                                       if (name_id != 0)
                                       {
                                           previous += ", " + facade.GetNameForID(name_id);

include/engine/guidance/assemble_route.hpp

@@ -1,8 +1,8 @@
 #ifndef ENGINE_GUIDANCE_ASSEMBLE_ROUTE_HPP
 #define ENGINE_GUIDANCE_ASSEMBLE_ROUTE_HPP
 
-#include "engine/guidance/route_leg.hpp"
 #include "engine/guidance/route.hpp"
+#include "engine/guidance/route_leg.hpp"
 
 #include <vector>
 

include/engine/guidance/assemble_steps.hpp

@@ -1,19 +1,19 @@
 #ifndef ENGINE_GUIDANCE_ASSEMBLE_STEPS_HPP_
 #define ENGINE_GUIDANCE_ASSEMBLE_STEPS_HPP_
 
+#include "extractor/guidance/turn_instruction.hpp"
+#include "extractor/travel_mode.hpp"
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "engine/guidance/step_maneuver.hpp"
 #include "engine/guidance/toolkit.hpp"
 #include "engine/internal_route_result.hpp"
 #include "engine/phantom_node.hpp"
-#include "extractor/guidance/turn_instruction.hpp"
-#include "extractor/travel_mode.hpp"
 #include "util/bearing.hpp"
 #include "util/coordinate.hpp"
 #include "util/coordinate_calculation.hpp"
-#include "util/guidance/toolkit.hpp"
 #include "util/guidance/entry_class.hpp"
+#include "util/guidance/toolkit.hpp"
 #include "util/typedefs.hpp"
 
 #include <boost/optional.hpp>
@@ -65,13 +65,17 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
 
     auto bearings = detail::getDepartBearings(leg_geometry);
 
-    StepManeuver maneuver{source_node.location, bearings.first,
-                          bearings.second,      extractor::guidance::TurnInstruction::NO_TURN(),
-                          WaypointType::Depart, 0};
-    Intersection intersection{
-        source_node.location,
-        std::vector<short>({bearings.second}),
-        std::vector<bool>({true}), Intersection::NO_INDEX, 0};
+    StepManeuver maneuver{source_node.location,
+                          bearings.first,
+                          bearings.second,
+                          extractor::guidance::TurnInstruction::NO_TURN(),
+                          WaypointType::Depart,
+                          0};
+    Intersection intersection{source_node.location,
+                              std::vector<short>({bearings.second}),
+                              std::vector<bool>({true}),
+                              Intersection::NO_INDEX,
+                              0};
 
     if (leg_data.size() > 0)
     {
@@ -94,8 +98,23 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
             {
                 BOOST_ASSERT(segment_duration >= 0);
                 const auto name = facade.GetNameForID(step_name_id);
+                const auto pronunciation = facade.GetPronunciationForID(step_name_id);
+                const auto destinations = facade.GetDestinationsForID(step_name_id);
                 const auto distance = leg_geometry.segment_distances[segment_index];
 
+                steps.push_back(RouteStep{step_name_id,
+                                          std::move(name),
+                                          std::move(pronunciation),
+                                          std::move(destinations),
+                                          NO_ROTARY_NAME,
+                                          segment_duration / 10.0,
+                                          distance,
+                                          path_point.travel_mode,
+                                          maneuver,
+                                          leg_geometry.FrontIndex(segment_index),
+                                          leg_geometry.BackIndex(segment_index) + 1,
+                                          {intersection}});
+
                 if (leg_data_index + 1 < leg_data.size())
                 {
                     step_name_id = leg_data[leg_data_index + 1].name_id;
@@ -104,26 +123,30 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
                 {
                     step_name_id = target_node.name_id;
                 }
-                steps.push_back(RouteStep{
-                    step_name_id, name, NO_ROTARY_NAME, segment_duration / 10.0, distance,
-                    path_point.travel_mode, maneuver, leg_geometry.FrontIndex(segment_index),
-                    leg_geometry.BackIndex(segment_index) + 1, {intersection}});
 
                 bearings = detail::getIntermediateBearings(leg_geometry, segment_index);
                 const auto entry_class = facade.GetEntryClass(path_point.entry_classid);
-                const auto bearing_class = facade.GetBearingClass(facade.GetBearingClassID(path_point.turn_via_node));
-                intersection.in = bearing_class.findMatchingBearing(util::bearing::reverseBearing(bearings.first));
+                const auto bearing_class =
+                    facade.GetBearingClass(facade.GetBearingClassID(path_point.turn_via_node));
+                intersection.in = bearing_class.findMatchingBearing(
+                    util::bearing::reverseBearing(bearings.first));
                 intersection.out = bearing_class.findMatchingBearing(bearings.second);
                 intersection.location = facade.GetCoordinateOfNode(path_point.turn_via_node);
                 intersection.bearings.clear();
-                std::copy(bearing_class.getAvailableBearings().begin(), bearing_class.getAvailableBearings().end(),
+                std::copy(bearing_class.getAvailableBearings().begin(),
+                          bearing_class.getAvailableBearings().end(),
                           std::back_inserter(intersection.bearings));
                 intersection.entry.clear();
                 for (auto idx : util::irange<std::size_t>(0, intersection.bearings.size()))
                 {
                     intersection.entry.push_back(entry_class.allowsEntry(idx));
                 }
-                maneuver = {intersection.location, bearings.first, bearings.second, path_point.turn_instruction, WaypointType::None, 0};
+                maneuver = {intersection.location,
+                            bearings.first,
+                            bearings.second,
+                            path_point.turn_instruction,
+                            WaypointType::None,
+                            0};
                 segment_index++;
                 segment_duration = 0;
             }
@@ -131,10 +154,18 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
         const auto distance = leg_geometry.segment_distances[segment_index];
         const int duration = segment_duration + target_duration;
         BOOST_ASSERT(duration >= 0);
-        steps.push_back(RouteStep{
-            step_name_id, facade.GetNameForID(step_name_id), NO_ROTARY_NAME, duration / 10.,
-            distance, target_mode, maneuver, leg_geometry.FrontIndex(segment_index),
-            leg_geometry.BackIndex(segment_index) + 1, {intersection}});
+        steps.push_back(RouteStep{step_name_id,
+                                  facade.GetNameForID(step_name_id),
+                                  facade.GetPronunciationForID(step_name_id),
+                                  facade.GetDestinationsForID(step_name_id),
+                                  NO_ROTARY_NAME,
+                                  duration / 10.,
+                                  distance,
+                                  target_mode,
+                                  maneuver,
+                                  leg_geometry.FrontIndex(segment_index),
+                                  leg_geometry.BackIndex(segment_index) + 1,
+                                  {intersection}});
     }
     // In this case the source + target are on the same edge segment
     else
@@ -148,30 +179,50 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
         int duration = target_duration - source_duration;
         BOOST_ASSERT(duration >= 0);
 
-        steps.push_back(RouteStep{
-            source_node.name_id, facade.GetNameForID(source_node.name_id), NO_ROTARY_NAME,
-            duration / 10., leg_geometry.segment_distances[segment_index], source_mode,
-            std::move(maneuver), leg_geometry.FrontIndex(segment_index),
-            leg_geometry.BackIndex(segment_index) + 1, {intersection}});
+        steps.push_back(RouteStep{source_node.name_id,
+                                  facade.GetNameForID(source_node.name_id),
+                                  facade.GetPronunciationForID(source_node.name_id),
+                                  facade.GetDestinationsForID(source_node.name_id),
+                                  NO_ROTARY_NAME,
+                                  duration / 10.,
+                                  leg_geometry.segment_distances[segment_index],
+                                  source_mode,
+                                  std::move(maneuver),
+                                  leg_geometry.FrontIndex(segment_index),
+                                  leg_geometry.BackIndex(segment_index) + 1,
+                                  {intersection}});
     }
 
     BOOST_ASSERT(segment_index == number_of_segments - 1);
     bearings = detail::getArriveBearings(leg_geometry);
     // This step has length zero, the only reason we need it is the target location
-    maneuver = {intersection.location, bearings.first, bearings.second, extractor::guidance::TurnInstruction::NO_TURN(), WaypointType::Arrive, 0};
+    maneuver = {intersection.location,
+                bearings.first,
+                bearings.second,
+                extractor::guidance::TurnInstruction::NO_TURN(),
+                WaypointType::Arrive,
+                0};
     intersection = {
         target_node.location,
         std::vector<short>({static_cast<short>(util::bearing::reverseBearing(bearings.first))}),
-        std::vector<bool>({true}), 0, Intersection::NO_INDEX};
+        std::vector<bool>({true}),
+        0,
+        Intersection::NO_INDEX};
 
     BOOST_ASSERT(!leg_geometry.locations.empty());
-    steps.push_back(RouteStep{target_node.name_id, facade.GetNameForID(target_node.name_id),
-                              NO_ROTARY_NAME, ZERO_DURATION, ZERO_DISTANCE, target_mode,
-                              std::move(maneuver), leg_geometry.locations.size() - 1,
+    steps.push_back(RouteStep{target_node.name_id,
+                              facade.GetNameForID(target_node.name_id),
+                              facade.GetPronunciationForID(target_node.name_id),
+                              facade.GetDestinationsForID(target_node.name_id),
+                              NO_ROTARY_NAME,
+                              ZERO_DURATION,
+                              ZERO_DISTANCE,
+                              target_mode,
+                              std::move(maneuver),
+                              leg_geometry.locations.size() - 1,
                               leg_geometry.locations.size(),
                               {intersection}});
 
-
     BOOST_ASSERT(steps.front().intersections.size() == 1);
     BOOST_ASSERT(steps.front().intersections.front().bearings.size() == 1);
     BOOST_ASSERT(steps.front().intersections.front().entry.size() == 1);

include/engine/guidance/leg_geometry.hpp

@@ -3,13 +3,14 @@
 
 #include "util/coordinate.hpp"
 #include "util/integer_range.hpp"
+#include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
 
 #include <cstddef>
 
-#include <vector>
 #include <cstdlib>
+#include <vector>
 
 namespace osrm
 {
@@ -30,9 +31,12 @@ struct LegGeometry
     std::vector<std::size_t> segment_offsets;
     // length of the segment in meters
     std::vector<double> segment_distances;
+    // original OSM node IDs for each coordinate
+    std::vector<OSMNodeID> osm_node_ids;
 
     // Per-coordinate metadata
-    struct Annotation {
+    struct Annotation
+    {
         double distance;
         double duration;
     };

include/engine/guidance/post_processing.hpp

@@ -1,9 +1,9 @@
 #ifndef ENGINE_GUIDANCE_POST_PROCESSING_HPP
 #define ENGINE_GUIDANCE_POST_PROCESSING_HPP
 
-#include "engine/phantom_node.hpp"
-#include "engine/guidance/route_step.hpp"
 #include "engine/guidance/leg_geometry.hpp"
+#include "engine/guidance/route_step.hpp"
+#include "engine/phantom_node.hpp"
 
 #include <vector>
 
@@ -37,7 +37,7 @@ std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
                                                const PhantomNode &source_node,
                                                const PhantomNode &target_node);
 
-//remove steps invalidated by post-processing
+// remove steps invalidated by post-processing
 std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps);
 
 // postProcess will break the connection between the leg geometry

include/engine/guidance/route_step.hpp

@@ -1,8 +1,8 @@
 #ifndef ROUTE_STEP_HPP
 #define ROUTE_STEP_HPP
 
-#include "engine/guidance/step_maneuver.hpp"
 #include "extractor/travel_mode.hpp"
+#include "engine/guidance/step_maneuver.hpp"
 #include "util/coordinate.hpp"
 #include "util/guidance/bearing_class.hpp"
 #include "util/guidance/entry_class.hpp"
@@ -39,16 +39,18 @@ struct Intersection
 inline Intersection getInvalidIntersection()
 {
     return {util::Coordinate{util::FloatLongitude{0.0}, util::FloatLatitude{0.0}},
-        {},
-        {},
-        Intersection::NO_INDEX,
-        Intersection::NO_INDEX};
+            {},
+            {},
+            Intersection::NO_INDEX,
+            Intersection::NO_INDEX};
 }
 
 struct RouteStep
 {
     unsigned name_id;
     std::string name;
+    std::string pronunciation;
+    std::string destinations;
     std::string rotary_name;
     double duration;
     double distance;
@@ -63,6 +65,8 @@ struct RouteStep
 inline RouteStep getInvalidRouteStep()
 {
     return {0,
+            "",
+            "",
             "",
             "",
             0,

include/engine/hint.hpp

@@ -32,9 +32,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "util/coordinate.hpp"
 
-#include <string>
 #include <cstdint>
 #include <iosfwd>
+#include <string>
 
 namespace osrm
 {
@@ -65,7 +65,8 @@ struct Hint
 
 static_assert(sizeof(Hint) == 60 + 4, "Hint is bigger than expected");
 constexpr std::size_t ENCODED_HINT_SIZE = 88;
-static_assert(ENCODED_HINT_SIZE / 4 * 3 >= sizeof(Hint), "ENCODED_HINT_SIZE does not match size of Hint");
+static_assert(ENCODED_HINT_SIZE / 4 * 3 >= sizeof(Hint),
+              "ENCODED_HINT_SIZE does not match size of Hint");
 }
 }
 

include/engine/internal_route_result.hpp

@@ -1,9 +1,9 @@
 #ifndef RAW_ROUTE_DATA_H
 #define RAW_ROUTE_DATA_H
 
-#include "engine/phantom_node.hpp"
 #include "extractor/guidance/turn_instruction.hpp"
 #include "extractor/travel_mode.hpp"
+#include "engine/phantom_node.hpp"
 #include "util/typedefs.hpp"
 
 #include "osrm/coordinate.hpp"

include/engine/map_matching/bayes_classifier.hpp

@@ -3,8 +3,8 @@
 
 #include <cmath>
 
-#include <vector>
 #include <utility>
+#include <vector>
 
 #include <boost/math/constants/constants.hpp>
 

include/engine/phantom_node.hpp

@@ -149,8 +149,8 @@ struct PhantomNode
     unsigned reverse_packed_geometry_id;
     struct ComponentType
     {
-        std::uint32_t id         : 31;
-        std::uint32_t is_tiny    : 1;
+        std::uint32_t id : 31;
+        std::uint32_t is_tiny : 1;
     } component;
     static_assert(sizeof(ComponentType) == 4, "ComponentType needs to be 4 bytes big");
 

include/engine/plugins/match.hpp

@@ -1,8 +1,8 @@
 #ifndef MATCH_HPP
 #define MATCH_HPP
 
-#include "engine/plugins/plugin_base.hpp"
 #include "engine/api/match_parameters.hpp"
+#include "engine/plugins/plugin_base.hpp"
 
 #include "engine/map_matching/bayes_classifier.hpp"
 #include "engine/routing_algorithms/map_matching.hpp"

include/engine/plugins/nearest.hpp

@@ -1,8 +1,8 @@
 #ifndef NEAREST_HPP
 #define NEAREST_HPP
 
-#include "engine/plugins/plugin_base.hpp"
 #include "engine/api/nearest_parameters.hpp"
+#include "engine/plugins/plugin_base.hpp"
 #include "osrm/json_container.hpp"
 
 namespace osrm

include/engine/plugins/plugin_base.hpp

@@ -1,15 +1,15 @@
 #ifndef BASE_PLUGIN_HPP
 #define BASE_PLUGIN_HPP
 
-#include "engine/datafacade/datafacade_base.hpp"
 #include "engine/api/base_parameters.hpp"
+#include "engine/datafacade/datafacade_base.hpp"
 #include "engine/phantom_node.hpp"
 #include "engine/status.hpp"
 
 #include "util/coordinate.hpp"
 #include "util/coordinate_calculation.hpp"
-#include "util/json_container.hpp"
 #include "util/integer_range.hpp"
+#include "util/json_container.hpp"
 
 #include <algorithm>
 #include <iterator>
@@ -31,11 +31,10 @@ class BasePlugin
 
     bool CheckAllCoordinates(const std::vector<util::Coordinate> &coordinates)
     {
-        return !std::any_of(std::begin(coordinates), std::end(coordinates),
-                            [](const util::Coordinate coordinate)
-                            {
-                                return !coordinate.IsValid();
-                            });
+        return !std::any_of(
+            std::begin(coordinates), std::end(coordinates), [](const util::Coordinate coordinate) {
+                return !coordinate.IsValid();
+            });
     }
 
     Status Error(const std::string &code,
@@ -53,43 +52,38 @@ class BasePlugin
     SnapPhantomNodes(const std::vector<PhantomNodePair> &phantom_node_pair_list) const
     {
         const auto check_component_id_is_tiny =
-            [](const std::pair<PhantomNode, PhantomNode> &phantom_pair)
-        {
-            return phantom_pair.first.component.is_tiny;
-        };
+            [](const std::pair<PhantomNode, PhantomNode> &phantom_pair) {
+                return phantom_pair.first.component.is_tiny;
+            };
 
         // are all phantoms from a tiny cc?
         const auto check_all_in_same_component =
-            [](const std::vector<std::pair<PhantomNode, PhantomNode>> &nodes)
-        {
-            const auto component_id = nodes.front().first.component.id;
+            [](const std::vector<std::pair<PhantomNode, PhantomNode>> &nodes) {
+                const auto component_id = nodes.front().first.component.id;
 
-            return std::all_of(std::begin(nodes), std::end(nodes),
-                               [component_id](const PhantomNodePair &phantom_pair)
-                               {
-                                   return component_id == phantom_pair.first.component.id;
-                               });
-        };
+                return std::all_of(std::begin(nodes),
+                                   std::end(nodes),
+                                   [component_id](const PhantomNodePair &phantom_pair) {
+                                       return component_id == phantom_pair.first.component.id;
+                                   });
+            };
 
         const auto fallback_to_big_component =
-            [](const std::pair<PhantomNode, PhantomNode> &phantom_pair)
-        {
-            if (phantom_pair.first.component.is_tiny && phantom_pair.second.IsValid() &&
-                !phantom_pair.second.component.is_tiny)
-            {
-                return phantom_pair.second;
-            }
-            return phantom_pair.first;
-        };
+            [](const std::pair<PhantomNode, PhantomNode> &phantom_pair) {
+                if (phantom_pair.first.component.is_tiny && phantom_pair.second.IsValid() &&
+                    !phantom_pair.second.component.is_tiny)
+                {
+                    return phantom_pair.second;
+                }
+                return phantom_pair.first;
+            };
 
-        const auto use_closed_phantom = [](const std::pair<PhantomNode, PhantomNode> &phantom_pair)
-        {
-            return phantom_pair.first;
-        };
+        const auto use_closed_phantom = [](
+            const std::pair<PhantomNode, PhantomNode> &phantom_pair) { return phantom_pair.first; };
 
-        const bool every_phantom_is_in_tiny_cc =
-            std::all_of(std::begin(phantom_node_pair_list), std::end(phantom_node_pair_list),
-                        check_component_id_is_tiny);
+        const bool every_phantom_is_in_tiny_cc = std::all_of(std::begin(phantom_node_pair_list),
+                                                             std::end(phantom_node_pair_list),
+                                                             check_component_id_is_tiny);
         auto all_in_same_component = check_all_in_same_component(phantom_node_pair_list);
 
         std::vector<PhantomNode> snapped_phantoms;
@@ -99,13 +93,17 @@ class BasePlugin
         // component
         if (every_phantom_is_in_tiny_cc && all_in_same_component)
         {
-            std::transform(phantom_node_pair_list.begin(), phantom_node_pair_list.end(),
-                           std::back_inserter(snapped_phantoms), use_closed_phantom);
+            std::transform(phantom_node_pair_list.begin(),
+                           phantom_node_pair_list.end(),
+                           std::back_inserter(snapped_phantoms),
+                           use_closed_phantom);
         }
         else
         {
-            std::transform(phantom_node_pair_list.begin(), phantom_node_pair_list.end(),
-                           std::back_inserter(snapped_phantoms), fallback_to_big_component);
+            std::transform(phantom_node_pair_list.begin(),
+                           phantom_node_pair_list.end(),
+                           std::back_inserter(snapped_phantoms),
+                           fallback_to_big_component);
         }
 
         return snapped_phantoms;
@@ -137,9 +135,11 @@ class BasePlugin
             }
             if (use_bearings && parameters.bearings[i])
             {
-                phantom_nodes[i] = facade.NearestPhantomNodesInRange(
-                    parameters.coordinates[i], radiuses[i], parameters.bearings[i]->bearing,
-                    parameters.bearings[i]->range);
+                phantom_nodes[i] =
+                    facade.NearestPhantomNodesInRange(parameters.coordinates[i],
+                                                      radiuses[i],
+                                                      parameters.bearings[i]->bearing,
+                                                      parameters.bearings[i]->range);
             }
             else
             {
@@ -179,15 +179,18 @@ class BasePlugin
             {
                 if (use_radiuses && parameters.radiuses[i])
                 {
-                    phantom_nodes[i] = facade.NearestPhantomNodes(
-                        parameters.coordinates[i], number_of_results, *parameters.radiuses[i],
-                        parameters.bearings[i]->bearing, parameters.bearings[i]->range);
+                    phantom_nodes[i] = facade.NearestPhantomNodes(parameters.coordinates[i],
+                                                                  number_of_results,
+                                                                  *parameters.radiuses[i],
+                                                                  parameters.bearings[i]->bearing,
+                                                                  parameters.bearings[i]->range);
                 }
                 else
                 {
-                    phantom_nodes[i] = facade.NearestPhantomNodes(
-                        parameters.coordinates[i], number_of_results,
-                        parameters.bearings[i]->bearing, parameters.bearings[i]->range);
+                    phantom_nodes[i] = facade.NearestPhantomNodes(parameters.coordinates[i],
+                                                                  number_of_results,
+                                                                  parameters.bearings[i]->bearing,
+                                                                  parameters.bearings[i]->range);
                 }
             }
             else
@@ -238,14 +241,17 @@ class BasePlugin
                 {
                     phantom_node_pairs[i] =
                         facade.NearestPhantomNodeWithAlternativeFromBigComponent(
-                            parameters.coordinates[i], *parameters.radiuses[i],
-                            parameters.bearings[i]->bearing, parameters.bearings[i]->range);
+                            parameters.coordinates[i],
+                            *parameters.radiuses[i],
+                            parameters.bearings[i]->bearing,
+                            parameters.bearings[i]->range);
                 }
                 else
                 {
                     phantom_node_pairs[i] =
                         facade.NearestPhantomNodeWithAlternativeFromBigComponent(
-                            parameters.coordinates[i], parameters.bearings[i]->bearing,
+                            parameters.coordinates[i],
+                            parameters.bearings[i]->bearing,
                             parameters.bearings[i]->range);
                 }
             }

include/engine/plugins/tile.hpp

@@ -1,8 +1,8 @@
 #ifndef TILEPLUGIN_HPP
 #define TILEPLUGIN_HPP
 
-#include "engine/plugins/plugin_base.hpp"
 #include "engine/api/tile_parameters.hpp"
+#include "engine/plugins/plugin_base.hpp"
 
 #include <string>
 

include/engine/plugins/trip.hpp

@@ -4,20 +4,20 @@
 #include "engine/plugins/plugin_base.hpp"
 
 #include "engine/api/trip_parameters.hpp"
-#include "engine/routing_algorithms/shortest_path.hpp"
 #include "engine/routing_algorithms/many_to_many.hpp"
+#include "engine/routing_algorithms/shortest_path.hpp"
 
 #include "osrm/json_container.hpp"
 
 #include <boost/assert.hpp>
 
-#include <cstdlib>
 #include <algorithm>
+#include <cstdlib>
+#include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
-#include <iterator>
 
 namespace osrm
 {

include/engine/plugins/viaroute.hpp

@@ -1,14 +1,14 @@
 #ifndef VIA_ROUTE_HPP
 #define VIA_ROUTE_HPP
 
+#include "engine/api/route_api.hpp"
 #include "engine/datafacade/datafacade_base.hpp"
 #include "engine/plugins/plugin_base.hpp"
-#include "engine/api/route_api.hpp"
 
-#include "engine/search_engine_data.hpp"
-#include "engine/routing_algorithms/shortest_path.hpp"
 #include "engine/routing_algorithms/alternative_path.hpp"
 #include "engine/routing_algorithms/direct_shortest_path.hpp"
+#include "engine/routing_algorithms/shortest_path.hpp"
+#include "engine/search_engine_data.hpp"
 #include "util/json_container.hpp"
 
 #include <cstdlib>

include/engine/routing_algorithms/alternative_path.hpp

@@ -130,16 +130,22 @@ class AlternativeRouting final
         {
             if (0 < forward_heap1.Size())
             {
-                AlternativeRoutingStep<true>(forward_heap1, reverse_heap1, &middle_node,
+                AlternativeRoutingStep<true>(forward_heap1,
+                                             reverse_heap1,
+                                             &middle_node,
                                              &upper_bound_to_shortest_path_distance,
-                                             via_node_candidate_list, forward_search_space,
+                                             via_node_candidate_list,
+                                             forward_search_space,
                                              min_edge_offset);
             }
             if (0 < reverse_heap1.Size())
             {
-                AlternativeRoutingStep<false>(forward_heap1, reverse_heap1, &middle_node,
+                AlternativeRoutingStep<false>(forward_heap1,
+                                              reverse_heap1,
+                                              &middle_node,
                                               &upper_bound_to_shortest_path_distance,
-                                              via_node_candidate_list, reverse_search_space,
+                                              via_node_candidate_list,
+                                              reverse_search_space,
                                               min_edge_offset);
             }
         }
@@ -168,10 +174,10 @@ class AlternativeRouting final
         else
         {
 
-            super::RetrievePackedPathFromSingleHeap(forward_heap1, middle_node,
-                                                    packed_forward_path);
-            super::RetrievePackedPathFromSingleHeap(reverse_heap1, middle_node,
-                                                    packed_reverse_path);
+            super::RetrievePackedPathFromSingleHeap(
+                forward_heap1, middle_node, packed_forward_path);
+            super::RetrievePackedPathFromSingleHeap(
+                reverse_heap1, middle_node, packed_reverse_path);
         }
 
         // this set is is used as an indicator if a node is on the shortest path
@@ -271,8 +277,8 @@ class AlternativeRouting final
         {
             std::reverse(packed_shortest_path.begin(), packed_shortest_path.end());
             packed_shortest_path.emplace_back(middle_node);
-            packed_shortest_path.insert(packed_shortest_path.end(), packed_reverse_path.begin(),
-                                        packed_reverse_path.end());
+            packed_shortest_path.insert(
+                packed_shortest_path.end(), packed_reverse_path.begin(), packed_reverse_path.end());
         }
         std::vector<RankedCandidateNode> ranked_candidates_list;
 
@@ -280,8 +286,11 @@ class AlternativeRouting final
         for (const NodeID node : preselected_node_list)
         {
             int length_of_via_path = 0, sharing_of_via_path = 0;
-            ComputeLengthAndSharingOfViaPath(node, &length_of_via_path, &sharing_of_via_path,
-                                             packed_shortest_path, min_edge_offset);
+            ComputeLengthAndSharingOfViaPath(node,
+                                             &length_of_via_path,
+                                             &sharing_of_via_path,
+                                             packed_shortest_path,
+                                             min_edge_offset);
             const int maximum_allowed_sharing =
                 static_cast<int>(upper_bound_to_shortest_path_distance * VIAPATH_GAMMA);
             if (sharing_of_via_path <= maximum_allowed_sharing &&
@@ -297,10 +306,16 @@ class AlternativeRouting final
         NodeID s_v_middle = SPECIAL_NODEID, v_t_middle = SPECIAL_NODEID;
         for (const RankedCandidateNode &candidate : ranked_candidates_list)
         {
-            if (ViaNodeCandidatePassesTTest(
-                    forward_heap1, reverse_heap1, forward_heap2, reverse_heap2, candidate,
-                    upper_bound_to_shortest_path_distance, &length_of_via_path, &s_v_middle,
-                    &v_t_middle, min_edge_offset))
+            if (ViaNodeCandidatePassesTTest(forward_heap1,
+                                            reverse_heap1,
+                                            forward_heap2,
+                                            reverse_heap2,
+                                            candidate,
+                                            upper_bound_to_shortest_path_distance,
+                                            &length_of_via_path,
+                                            &s_v_middle,
+                                            &v_t_middle,
+                                            min_edge_offset))
             {
                 // select first admissable
                 selected_via_node = candidate.node;
@@ -322,7 +337,8 @@ class AlternativeRouting final
 
             super::UnpackPath(
                 // -- packed input
-                packed_shortest_path.begin(), packed_shortest_path.end(),
+                packed_shortest_path.begin(),
+                packed_shortest_path.end(),
                 // -- start of route
                 phantom_node_pair,
                 // -- unpacked output
@@ -334,8 +350,13 @@ class AlternativeRouting final
         {
             std::vector<NodeID> packed_alternate_path;
             // retrieve alternate path
-            RetrievePackedAlternatePath(forward_heap1, reverse_heap1, forward_heap2, reverse_heap2,
-                                        s_v_middle, v_t_middle, packed_alternate_path);
+            RetrievePackedAlternatePath(forward_heap1,
+                                        reverse_heap1,
+                                        forward_heap2,
+                                        reverse_heap2,
+                                        s_v_middle,
+                                        v_t_middle,
+                                        packed_alternate_path);
 
             raw_route_data.alt_source_traversed_in_reverse.push_back(
                 (packed_alternate_path.front() !=
@@ -345,8 +366,10 @@ class AlternativeRouting final
                  phantom_node_pair.target_phantom.forward_segment_id.id));
 
             // unpack the alternate path
-            super::UnpackPath(packed_alternate_path.begin(), packed_alternate_path.end(),
-                              phantom_node_pair, raw_route_data.unpacked_alternative);
+            super::UnpackPath(packed_alternate_path.begin(),
+                              packed_alternate_path.end(),
+                              phantom_node_pair,
+                              raw_route_data.unpacked_alternative);
 
             raw_route_data.alternative_path_length = length_of_via_path;
         }
@@ -372,8 +395,8 @@ class AlternativeRouting final
         packed_path.pop_back(); // remove middle node. It's in both half-paths
 
         // fetch patched path [v,t]
-        super::RetrievePackedPathFromHeap(forward_heap2, reverse_heap1, v_t_middle,
-                                          packed_v_t_path);
+        super::RetrievePackedPathFromHeap(
+            forward_heap2, reverse_heap1, v_t_middle, packed_v_t_path);
 
         packed_path.insert(packed_path.end(), packed_v_t_path.begin(), packed_v_t_path.end());
     }
@@ -410,9 +433,15 @@ class AlternativeRouting final
         const bool constexpr DO_NOT_FORCE_LOOPS = false;
         while (!new_reverse_heap.Empty())
         {
-            super::RoutingStep(new_reverse_heap, existing_forward_heap, s_v_middle,
-                               upper_bound_s_v_path_length, min_edge_offset, false,
-                               STALLING_ENABLED, DO_NOT_FORCE_LOOPS, DO_NOT_FORCE_LOOPS);
+            super::RoutingStep(new_reverse_heap,
+                               existing_forward_heap,
+                               s_v_middle,
+                               upper_bound_s_v_path_length,
+                               min_edge_offset,
+                               false,
+                               STALLING_ENABLED,
+                               DO_NOT_FORCE_LOOPS,
+                               DO_NOT_FORCE_LOOPS);
         }
         // compute path <v,..,t> by reusing backward search from node t
         NodeID v_t_middle = SPECIAL_NODEID;
@@ -420,9 +449,15 @@ class AlternativeRouting final
         new_forward_heap.Insert(via_node, 0, via_node);
         while (!new_forward_heap.Empty())
         {
-            super::RoutingStep(new_forward_heap, existing_reverse_heap, v_t_middle,
-                               upper_bound_of_v_t_path_length, min_edge_offset, true,
-                               STALLING_ENABLED, DO_NOT_FORCE_LOOPS, DO_NOT_FORCE_LOOPS);
+            super::RoutingStep(new_forward_heap,
+                               existing_reverse_heap,
+                               v_t_middle,
+                               upper_bound_of_v_t_path_length,
+                               min_edge_offset,
+                               true,
+                               STALLING_ENABLED,
+                               DO_NOT_FORCE_LOOPS,
+                               DO_NOT_FORCE_LOOPS);
         }
         *real_length_of_via_path = upper_bound_s_v_path_length + upper_bound_of_v_t_path_length;
 
@@ -432,10 +467,10 @@ class AlternativeRouting final
         }
 
         // retrieve packed paths
-        super::RetrievePackedPathFromHeap(existing_forward_heap, new_reverse_heap, s_v_middle,
-                                          packed_s_v_path);
-        super::RetrievePackedPathFromHeap(new_forward_heap, existing_reverse_heap, v_t_middle,
-                                          packed_v_t_path);
+        super::RetrievePackedPathFromHeap(
+            existing_forward_heap, new_reverse_heap, s_v_middle, packed_s_v_path);
+        super::RetrievePackedPathFromHeap(
+            new_forward_heap, existing_reverse_heap, v_t_middle, packed_v_t_path);
 
         // partial unpacking, compute sharing
         // First partially unpack s-->v until paths deviate, note length of common path.
@@ -501,7 +536,8 @@ class AlternativeRouting final
                 if (packed_v_t_path[via_path_index] == packed_shortest_path[shortest_path_index])
                 {
                     super::UnpackEdge(packed_v_t_path[via_path_index - 1],
-                                      packed_v_t_path[via_path_index], partially_unpacked_via_path);
+                                      packed_v_t_path[via_path_index],
+                                      partially_unpacked_via_path);
                     super::UnpackEdge(packed_shortest_path[shortest_path_index - 1],
                                       packed_shortest_path[shortest_path_index],
                                       partially_unpacked_shortest_path);
@@ -699,9 +735,15 @@ class AlternativeRouting final
         const bool constexpr DO_NOT_FORCE_LOOPS = false;
         while (new_reverse_heap.Size() > 0)
         {
-            super::RoutingStep(new_reverse_heap, existing_forward_heap, *s_v_middle,
-                               upper_bound_s_v_path_length, min_edge_offset, false,
-                               STALLING_ENABLED, DO_NOT_FORCE_LOOPS, DO_NOT_FORCE_LOOPS);
+            super::RoutingStep(new_reverse_heap,
+                               existing_forward_heap,
+                               *s_v_middle,
+                               upper_bound_s_v_path_length,
+                               min_edge_offset,
+                               false,
+                               STALLING_ENABLED,
+                               DO_NOT_FORCE_LOOPS,
+                               DO_NOT_FORCE_LOOPS);
         }
 
         if (INVALID_EDGE_WEIGHT == upper_bound_s_v_path_length)
@@ -715,9 +757,15 @@ class AlternativeRouting final
         new_forward_heap.Insert(candidate.node, 0, candidate.node);
         while (new_forward_heap.Size() > 0)
         {
-            super::RoutingStep(new_forward_heap, existing_reverse_heap, *v_t_middle,
-                               upper_bound_of_v_t_path_length, min_edge_offset, true,
-                               STALLING_ENABLED, DO_NOT_FORCE_LOOPS, DO_NOT_FORCE_LOOPS);
+            super::RoutingStep(new_forward_heap,
+                               existing_reverse_heap,
+                               *v_t_middle,
+                               upper_bound_of_v_t_path_length,
+                               min_edge_offset,
+                               true,
+                               STALLING_ENABLED,
+                               DO_NOT_FORCE_LOOPS,
+                               DO_NOT_FORCE_LOOPS);
         }
 
         if (INVALID_EDGE_WEIGHT == upper_bound_of_v_t_path_length)
@@ -728,11 +776,11 @@ class AlternativeRouting final
         *length_of_via_path = upper_bound_s_v_path_length + upper_bound_of_v_t_path_length;
 
         // retrieve packed paths
-        super::RetrievePackedPathFromHeap(existing_forward_heap, new_reverse_heap, *s_v_middle,
-                                          packed_s_v_path);
+        super::RetrievePackedPathFromHeap(
+            existing_forward_heap, new_reverse_heap, *s_v_middle, packed_s_v_path);
 
-        super::RetrievePackedPathFromHeap(new_forward_heap, existing_reverse_heap, *v_t_middle,
-                                          packed_v_t_path);
+        super::RetrievePackedPathFromHeap(
+            new_forward_heap, existing_reverse_heap, *v_t_middle, packed_v_t_path);
 
         NodeID s_P = *s_v_middle, t_P = *v_t_middle;
         if (SPECIAL_NODEID == s_P)
@@ -812,7 +860,8 @@ class AlternativeRouting final
         // Traverse path s-->v
         BOOST_ASSERT(!packed_v_t_path.empty());
         for (unsigned i = 0, packed_path_length = static_cast<unsigned>(packed_v_t_path.size() - 1);
-             (i < packed_path_length) && unpack_stack.empty(); ++i)
+             (i < packed_path_length) && unpack_stack.empty();
+             ++i)
         {
             const EdgeID edgeID =
                 facade->FindEdgeInEitherDirection(packed_v_t_path[i], packed_v_t_path[i + 1]);
@@ -884,14 +933,26 @@ class AlternativeRouting final
         {
             if (!forward_heap3.Empty())
             {
-                super::RoutingStep(forward_heap3, reverse_heap3, middle, upper_bound,
-                                   min_edge_offset, true, STALLING_ENABLED, DO_NOT_FORCE_LOOPS,
+                super::RoutingStep(forward_heap3,
+                                   reverse_heap3,
+                                   middle,
+                                   upper_bound,
+                                   min_edge_offset,
+                                   true,
+                                   STALLING_ENABLED,
+                                   DO_NOT_FORCE_LOOPS,
                                    DO_NOT_FORCE_LOOPS);
             }
             if (!reverse_heap3.Empty())
             {
-                super::RoutingStep(reverse_heap3, forward_heap3, middle, upper_bound,
-                                   min_edge_offset, false, STALLING_ENABLED, DO_NOT_FORCE_LOOPS,
+                super::RoutingStep(reverse_heap3,
+                                   forward_heap3,
+                                   middle,
+                                   upper_bound,
+                                   min_edge_offset,
+                                   false,
+                                   STALLING_ENABLED,
+                                   DO_NOT_FORCE_LOOPS,
                                    DO_NOT_FORCE_LOOPS);
             }
         }

include/engine/routing_algorithms/direct_shortest_path.hpp

@@ -102,12 +102,22 @@ class DirectShortestPathRouting final
             forward_core_heap.Clear();
             reverse_core_heap.Clear();
 
-            super::SearchWithCore(forward_heap, reverse_heap, forward_core_heap, reverse_core_heap,
-                                  distance, packed_leg, DO_NOT_FORCE_LOOPS, DO_NOT_FORCE_LOOPS);
+            super::SearchWithCore(forward_heap,
+                                  reverse_heap,
+                                  forward_core_heap,
+                                  reverse_core_heap,
+                                  distance,
+                                  packed_leg,
+                                  DO_NOT_FORCE_LOOPS,
+                                  DO_NOT_FORCE_LOOPS);
         }
         else
         {
-            super::Search(forward_heap, reverse_heap, distance, packed_leg, DO_NOT_FORCE_LOOPS,
+            super::Search(forward_heap,
+                          reverse_heap,
+                          distance,
+                          packed_leg,
+                          DO_NOT_FORCE_LOOPS,
                           DO_NOT_FORCE_LOOPS);
         }
 
@@ -128,7 +138,9 @@ class DirectShortestPathRouting final
         raw_route_data.target_traversed_in_reverse.push_back(
             (packed_leg.back() != phantom_node_pair.target_phantom.forward_segment_id.id));
 
-        super::UnpackPath(packed_leg.begin(), packed_leg.end(), phantom_node_pair,
+        super::UnpackPath(packed_leg.begin(),
+                          packed_leg.end(),
+                          phantom_node_pair,
                           raw_route_data.unpacked_path_segments.front());
     }
 };

include/engine/routing_algorithms/many_to_many.hpp

@@ -66,8 +66,7 @@ class ManyToManyRouting final
         SearchSpaceWithBuckets search_space_with_buckets;
 
         unsigned column_idx = 0;
-        const auto search_target_phantom = [&](const PhantomNode &phantom)
-        {
+        const auto search_target_phantom = [&](const PhantomNode &phantom) {
             query_heap.Clear();
             // insert target(s) at distance 0
 
@@ -94,8 +93,7 @@ class ManyToManyRouting final
 
         // for each source do forward search
         unsigned row_idx = 0;
-        const auto search_source_phantom = [&](const PhantomNode &phantom)
-        {
+        const auto search_source_phantom = [&](const PhantomNode &phantom) {
             query_heap.Clear();
             // insert target(s) at distance 0
 
@@ -115,8 +113,11 @@ class ManyToManyRouting final
             // explore search space
             while (!query_heap.Empty())
             {
-                ForwardRoutingStep(row_idx, number_of_targets, query_heap,
-                                   search_space_with_buckets, result_table);
+                ForwardRoutingStep(row_idx,
+                                   number_of_targets,
+                                   query_heap,
+                                   search_space_with_buckets,
+                                   result_table);
             }
             ++row_idx;
         };

include/engine/routing_algorithms/map_matching.hpp

@@ -4,12 +4,12 @@
 #include "engine/routing_algorithms/routing_base.hpp"
 
 #include "engine/map_matching/hidden_markov_model.hpp"
-#include "engine/map_matching/sub_matching.hpp"
 #include "engine/map_matching/matching_confidence.hpp"
+#include "engine/map_matching/sub_matching.hpp"
 
 #include "util/coordinate_calculation.hpp"
-#include "util/json_logger.hpp"
 #include "util/for_each_pair.hpp"
+#include "util/json_logger.hpp"
 
 #include <cstddef>
 
@@ -86,8 +86,7 @@ class MapMatching final : public BasicRoutingInterface<DataFacadeT, MapMatching<
 
         const bool use_timestamps = trace_timestamps.size() > 1;
 
-        const auto median_sample_time = [&]
-        {
+        const auto median_sample_time = [&] {
             if (use_timestamps)
             {
                 return std::max(1u, GetMedianSampleTime(trace_timestamps));
@@ -98,8 +97,7 @@ class MapMatching final : public BasicRoutingInterface<DataFacadeT, MapMatching<
             }
         }();
         const auto max_broken_time = median_sample_time * MAX_BROKEN_STATES;
-        const auto max_distance_delta = [&]
-        {
+        const auto max_distance_delta = [&] {
             if (use_timestamps)
             {
                 return median_sample_time * MAX_SPEED;
@@ -116,10 +114,10 @@ class MapMatching final : public BasicRoutingInterface<DataFacadeT, MapMatching<
             for (auto t = 0UL; t < candidates_list.size(); ++t)
             {
                 emission_log_probabilities[t].resize(candidates_list[t].size());
-                std::transform(candidates_list[t].begin(), candidates_list[t].end(),
+                std::transform(candidates_list[t].begin(),
+                               candidates_list[t].end(),
                                emission_log_probabilities[t].begin(),
-                               [this](const PhantomNodeWithDistance &candidate)
-                               {
+                               [this](const PhantomNodeWithDistance &candidate) {
                                    return default_emission_log_probability(candidate.distance);
                                });
             }
@@ -134,19 +132,19 @@ class MapMatching final : public BasicRoutingInterface<DataFacadeT, MapMatching<
                     map_matching::EmissionLogProbability emission_log_probability(
                         *trace_gps_precision[t]);
                     std::transform(
-                        candidates_list[t].begin(), candidates_list[t].end(),
+                        candidates_list[t].begin(),
+                        candidates_list[t].end(),
                         emission_log_probabilities[t].begin(),
-                        [&emission_log_probability](const PhantomNodeWithDistance &candidate)
-                        {
+                        [&emission_log_probability](const PhantomNodeWithDistance &candidate) {
                             return emission_log_probability(candidate.distance);
                         });
                 }
                 else
                 {
-                    std::transform(candidates_list[t].begin(), candidates_list[t].end(),
+                    std::transform(candidates_list[t].begin(),
+                                   candidates_list[t].end(),
                                    emission_log_probabilities[t].begin(),
-                                   [this](const PhantomNodeWithDistance &candidate)
-                                   {
+                                   [this](const PhantomNodeWithDistance &candidate) {
                                        return default_emission_log_probability(candidate.distance);
                                    });
                 }
@@ -269,14 +267,19 @@ class MapMatching final : public BasicRoutingInterface<DataFacadeT, MapMatching<
                         forward_core_heap.Clear();
                         reverse_core_heap.Clear();
                         network_distance = super::GetNetworkDistanceWithCore(
-                            forward_heap, reverse_heap, forward_core_heap, reverse_core_heap,
+                            forward_heap,
+                            reverse_heap,
+                            forward_core_heap,
+                            reverse_core_heap,
                             prev_unbroken_timestamps_list[s].phantom_node,
-                            current_timestamps_list[s_prime].phantom_node, duration_uppder_bound);
+                            current_timestamps_list[s_prime].phantom_node,
+                            duration_uppder_bound);
                     }
                     else
                     {
                         network_distance = super::GetNetworkDistance(
-                            forward_heap, reverse_heap,
+                            forward_heap,
+                            reverse_heap,
                             prev_unbroken_timestamps_list[s].phantom_node,
                             current_timestamps_list[s_prime].phantom_node);
                     }
@@ -398,10 +401,10 @@ class MapMatching final : public BasicRoutingInterface<DataFacadeT, MapMatching<
                 matching_distance += model.path_distances[timestamp_index][location_index];
             }
             util::for_each_pair(
-                reconstructed_indices, [&trace_distance, &trace_coordinates](
-                                           const std::pair<std::size_t, std::size_t> &prev,
-                                           const std::pair<std::size_t, std::size_t> &curr)
-                {
+                reconstructed_indices,
+                [&trace_distance,
+                 &trace_coordinates](const std::pair<std::size_t, std::size_t> &prev,
+                                     const std::pair<std::size_t, std::size_t> &curr) {
                     trace_distance += util::coordinate_calculation::haversineDistance(
                         trace_coordinates[prev.first], trace_coordinates[curr.first]);
                 });

include/engine/routing_algorithms/routing_base.hpp

@@ -1,9 +1,9 @@
 #ifndef ROUTING_BASE_HPP
 #define ROUTING_BASE_HPP
 
+#include "extractor/guidance/turn_instruction.hpp"
 #include "engine/internal_route_result.hpp"
 #include "engine/search_engine_data.hpp"
-#include "extractor/guidance/turn_instruction.hpp"
 #include "util/coordinate_calculation.hpp"
 #include "util/typedefs.hpp"
 
@@ -228,8 +228,9 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
 
         BOOST_ASSERT(*packed_path_begin == phantom_node_pair.source_phantom.forward_segment_id.id ||
                      *packed_path_begin == phantom_node_pair.source_phantom.reverse_segment_id.id);
-        BOOST_ASSERT(*std::prev(packed_path_end) == phantom_node_pair.target_phantom.forward_segment_id.id ||
-                     *std::prev(packed_path_end) == phantom_node_pair.target_phantom.reverse_segment_id.id);
+        BOOST_ASSERT(
+            *std::prev(packed_path_end) == phantom_node_pair.target_phantom.forward_segment_id.id ||
+            *std::prev(packed_path_end) == phantom_node_pair.target_phantom.reverse_segment_id.id);
 
         std::pair<NodeID, NodeID> edge;
         while (!recursion_stack.empty())
@@ -322,8 +323,11 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
                 for (std::size_t i = start_index; i < end_index; ++i)
                 {
                     unpacked_path.push_back(
-                        PathData{id_vector[i], name_index, weight_vector[i],
-                                 extractor::guidance::TurnInstruction::NO_TURN(), travel_mode,
+                        PathData{id_vector[i],
+                                 name_index,
+                                 weight_vector[i],
+                                 extractor::guidance::TurnInstruction::NO_TURN(),
+                                 travel_mode,
                                  INVALID_ENTRY_CLASSID});
                 }
                 BOOST_ASSERT(unpacked_path.size() > 0);
@@ -381,7 +385,9 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
             BOOST_ASSERT(i < id_vector.size());
             BOOST_ASSERT(phantom_node_pair.target_phantom.forward_travel_mode > 0);
             unpacked_path.push_back(PathData{
-                id_vector[i], phantom_node_pair.target_phantom.name_id, weight_vector[i],
+                id_vector[i],
+                phantom_node_pair.target_phantom.name_id,
+                weight_vector[i],
                 extractor::guidance::TurnInstruction::NO_TURN(),
                 target_traversed_in_reverse ? phantom_node_pair.target_phantom.backward_travel_mode
                                             : phantom_node_pair.target_phantom.forward_travel_mode,
@@ -544,13 +550,27 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
         {
             if (!forward_heap.Empty())
             {
-                RoutingStep(forward_heap, reverse_heap, middle, distance, min_edge_offset, true,
-                            STALLING_ENABLED, force_loop_forward, force_loop_reverse);
+                RoutingStep(forward_heap,
+                            reverse_heap,
+                            middle,
+                            distance,
+                            min_edge_offset,
+                            true,
+                            STALLING_ENABLED,
+                            force_loop_forward,
+                            force_loop_reverse);
             }
             if (!reverse_heap.Empty())
             {
-                RoutingStep(reverse_heap, forward_heap, middle, distance, min_edge_offset, false,
-                            STALLING_ENABLED, force_loop_reverse, force_loop_forward);
+                RoutingStep(reverse_heap,
+                            forward_heap,
+                            middle,
+                            distance,
+                            min_edge_offset,
+                            false,
+                            STALLING_ENABLED,
+                            force_loop_reverse,
+                            force_loop_forward);
             }
         }
 
@@ -622,8 +642,15 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
                 }
                 else
                 {
-                    RoutingStep(forward_heap, reverse_heap, middle, distance, min_edge_offset, true,
-                                STALLING_ENABLED, force_loop_forward, force_loop_reverse);
+                    RoutingStep(forward_heap,
+                                reverse_heap,
+                                middle,
+                                distance,
+                                min_edge_offset,
+                                true,
+                                STALLING_ENABLED,
+                                force_loop_forward,
+                                force_loop_reverse);
                 }
             }
             if (!reverse_heap.Empty())
@@ -636,8 +663,15 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
                 }
                 else
                 {
-                    RoutingStep(reverse_heap, forward_heap, middle, distance, min_edge_offset,
-                                false, STALLING_ENABLED, force_loop_reverse, force_loop_forward);
+                    RoutingStep(reverse_heap,
+                                forward_heap,
+                                middle,
+                                distance,
+                                min_edge_offset,
+                                false,
+                                STALLING_ENABLED,
+                                force_loop_reverse,
+                                force_loop_forward);
                 }
             }
         }
@@ -690,12 +724,24 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
         while (0 < forward_core_heap.Size() && 0 < reverse_core_heap.Size() &&
                distance > (forward_core_heap.MinKey() + reverse_core_heap.MinKey()))
         {
-            RoutingStep(forward_core_heap, reverse_core_heap, middle, distance,
-                        min_core_edge_offset, true, STALLING_DISABLED, force_loop_forward,
+            RoutingStep(forward_core_heap,
+                        reverse_core_heap,
+                        middle,
+                        distance,
+                        min_core_edge_offset,
+                        true,
+                        STALLING_DISABLED,
+                        force_loop_forward,
                         force_loop_reverse);
 
-            RoutingStep(reverse_core_heap, forward_core_heap, middle, distance,
-                        min_core_edge_offset, false, STALLING_DISABLED, force_loop_reverse,
+            RoutingStep(reverse_core_heap,
+                        forward_core_heap,
+                        middle,
+                        distance,
+                        min_core_edge_offset,
+                        false,
+                        STALLING_DISABLED,
+                        force_loop_reverse,
                         force_loop_forward);
         }
 
@@ -724,8 +770,8 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
             else
             {
                 std::vector<NodeID> packed_core_leg;
-                RetrievePackedPathFromHeap(forward_core_heap, reverse_core_heap, middle,
-                                           packed_core_leg);
+                RetrievePackedPathFromHeap(
+                    forward_core_heap, reverse_core_heap, middle, packed_core_leg);
                 BOOST_ASSERT(packed_core_leg.size() > 0);
                 RetrievePackedPathFromSingleHeap(forward_heap, packed_core_leg.front(), packed_leg);
                 std::reverse(packed_leg.begin(), packed_leg.end());
@@ -872,8 +918,15 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
 
         int duration = INVALID_EDGE_WEIGHT;
         std::vector<NodeID> packed_path;
-        SearchWithCore(forward_heap, reverse_heap, forward_core_heap, reverse_core_heap, duration,
-                       packed_path, DO_NOT_FORCE_LOOPS, DO_NOT_FORCE_LOOPS, duration_upper_bound);
+        SearchWithCore(forward_heap,
+                       reverse_heap,
+                       forward_core_heap,
+                       reverse_core_heap,
+                       duration,
+                       packed_path,
+                       DO_NOT_FORCE_LOOPS,
+                       DO_NOT_FORCE_LOOPS,
+                       duration_upper_bound);
 
         double distance = std::numeric_limits<double>::max();
         if (duration != INVALID_EDGE_WEIGHT)
@@ -926,8 +979,13 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
 
         int duration = INVALID_EDGE_WEIGHT;
         std::vector<NodeID> packed_path;
-        Search(forward_heap, reverse_heap, duration, packed_path, DO_NOT_FORCE_LOOPS,
-               DO_NOT_FORCE_LOOPS, duration_upper_bound);
+        Search(forward_heap,
+               reverse_heap,
+               duration,
+               packed_path,
+               DO_NOT_FORCE_LOOPS,
+               DO_NOT_FORCE_LOOPS,
+               duration_upper_bound);
 
         if (duration == INVALID_EDGE_WEIGHT)
         {

include/engine/routing_algorithms/shortest_path.hpp

@@ -57,13 +57,13 @@ class ShortestPathRouting final
         if (search_from_forward_node)
         {
             forward_heap.Insert(source_phantom.forward_segment_id.id,
-                                    -source_phantom.GetForwardWeightPlusOffset(),
+                                -source_phantom.GetForwardWeightPlusOffset(),
                                 source_phantom.forward_segment_id.id);
         }
         if (search_from_reverse_node)
         {
             forward_heap.Insert(source_phantom.reverse_segment_id.id,
-                                    -source_phantom.GetReverseWeightPlusOffset(),
+                                -source_phantom.GetReverseWeightPlusOffset(),
                                 source_phantom.reverse_segment_id.id);
         }
         if (search_to_forward_node)
@@ -96,16 +96,25 @@ class ShortestPathRouting final
             reverse_core_heap.Clear();
             BOOST_ASSERT(forward_core_heap.Size() == 0);
             BOOST_ASSERT(reverse_core_heap.Size() == 0);
-            super::SearchWithCore(forward_heap, reverse_heap, forward_core_heap, reverse_core_heap,
-                                  new_total_distance, leg_packed_path, needs_loop_forwad,
+            super::SearchWithCore(forward_heap,
+                                  reverse_heap,
+                                  forward_core_heap,
+                                  reverse_core_heap,
+                                  new_total_distance,
+                                  leg_packed_path,
+                                  needs_loop_forwad,
                                   needs_loop_backwards);
         }
         else
         {
-            super::Search(forward_heap, reverse_heap, new_total_distance, leg_packed_path,
-                          needs_loop_forwad, needs_loop_backwards);
+            super::Search(forward_heap,
+                          reverse_heap,
+                          new_total_distance,
+                          leg_packed_path,
+                          needs_loop_forwad,
+                          needs_loop_backwards);
         }
-        new_total_distance += std::min(total_distance_to_forward,total_distance_to_reverse);
+        new_total_distance += std::min(total_distance_to_forward, total_distance_to_reverse);
     }
 
     // searches shortest path between:
@@ -159,14 +168,20 @@ class ShortestPathRouting final
                 reverse_core_heap.Clear();
                 BOOST_ASSERT(forward_core_heap.Size() == 0);
                 BOOST_ASSERT(reverse_core_heap.Size() == 0);
-                super::SearchWithCore(
-                    forward_heap, reverse_heap, forward_core_heap, reverse_core_heap,
-                    new_total_distance_to_forward, leg_packed_path_forward,
-                    super::NeedsLoopForward(source_phantom, target_phantom), DO_NOT_FORCE_LOOP);
+                super::SearchWithCore(forward_heap,
+                                      reverse_heap,
+                                      forward_core_heap,
+                                      reverse_core_heap,
+                                      new_total_distance_to_forward,
+                                      leg_packed_path_forward,
+                                      super::NeedsLoopForward(source_phantom, target_phantom),
+                                      DO_NOT_FORCE_LOOP);
             }
             else
             {
-                super::Search(forward_heap, reverse_heap, new_total_distance_to_forward,
+                super::Search(forward_heap,
+                              reverse_heap,
+                              new_total_distance_to_forward,
                               leg_packed_path_forward,
                               super::NeedsLoopForward(source_phantom, target_phantom),
                               DO_NOT_FORCE_LOOP);
@@ -202,15 +217,22 @@ class ShortestPathRouting final
                 reverse_core_heap.Clear();
                 BOOST_ASSERT(forward_core_heap.Size() == 0);
                 BOOST_ASSERT(reverse_core_heap.Size() == 0);
-                super::SearchWithCore(forward_heap, reverse_heap, forward_core_heap,
-                                      reverse_core_heap, new_total_distance_to_reverse,
-                                      leg_packed_path_reverse, DO_NOT_FORCE_LOOP,
+                super::SearchWithCore(forward_heap,
+                                      reverse_heap,
+                                      forward_core_heap,
+                                      reverse_core_heap,
+                                      new_total_distance_to_reverse,
+                                      leg_packed_path_reverse,
+                                      DO_NOT_FORCE_LOOP,
                                       super::NeedsLoopBackwards(source_phantom, target_phantom));
             }
             else
             {
-                super::Search(forward_heap, reverse_heap, new_total_distance_to_reverse,
-                              leg_packed_path_reverse, DO_NOT_FORCE_LOOP,
+                super::Search(forward_heap,
+                              reverse_heap,
+                              new_total_distance_to_reverse,
+                              leg_packed_path_reverse,
+                              DO_NOT_FORCE_LOOP,
                               super::NeedsLoopBackwards(source_phantom, target_phantom));
             }
         }
@@ -231,7 +253,9 @@ class ShortestPathRouting final
             auto leg_begin = total_packed_path.begin() + packed_leg_begin[current_leg];
             auto leg_end = total_packed_path.begin() + packed_leg_begin[current_leg + 1];
             const auto &unpack_phantom_node_pair = phantom_nodes_vector[current_leg];
-            super::UnpackPath(leg_begin, leg_end, unpack_phantom_node_pair,
+            super::UnpackPath(leg_begin,
+                              leg_end,
+                              unpack_phantom_node_pair,
                               raw_route_data.unpacked_path_segments[current_leg]);
 
             raw_route_data.source_traversed_in_reverse.push_back(
@@ -247,7 +271,9 @@ class ShortestPathRouting final
                     const boost::optional<bool> continue_straight_at_waypoint,
                     InternalRouteResult &raw_route_data) const
     {
-        const bool allow_uturn_at_waypoint = !(continue_straight_at_waypoint ? *continue_straight_at_waypoint : super::facade->GetContinueStraightDefault());
+        const bool allow_uturn_at_waypoint =
+            !(continue_straight_at_waypoint ? *continue_straight_at_waypoint
+                                            : super::facade->GetContinueStraightDefault());
 
         engine_working_data.InitializeOrClearFirstThreadLocalStorage(
             super::facade->GetNumberOfNodes());
@@ -300,12 +326,20 @@ class ShortestPathRouting final
             {
                 if (allow_uturn_at_waypoint)
                 {
-                    SearchWithUTurn(forward_heap, reverse_heap, forward_core_heap,
-                                    reverse_core_heap, search_from_forward_node,
-                                    search_from_reverse_node, search_to_forward_node,
-                                    search_to_reverse_node, source_phantom, target_phantom,
-                                    total_distance_to_forward, total_distance_to_reverse,
-                                    new_total_distance_to_forward, packed_leg_to_forward);
+                    SearchWithUTurn(forward_heap,
+                                    reverse_heap,
+                                    forward_core_heap,
+                                    reverse_core_heap,
+                                    search_from_forward_node,
+                                    search_from_reverse_node,
+                                    search_to_forward_node,
+                                    search_to_reverse_node,
+                                    source_phantom,
+                                    target_phantom,
+                                    total_distance_to_forward,
+                                    total_distance_to_reverse,
+                                    new_total_distance_to_forward,
+                                    packed_leg_to_forward);
                     // if only the reverse node is valid (e.g. when using the match plugin) we
                     // actually need to move
                     if (!target_phantom.forward_segment_id.enabled)
@@ -323,12 +357,22 @@ class ShortestPathRouting final
                 }
                 else
                 {
-                    Search(forward_heap, reverse_heap, forward_core_heap, reverse_core_heap,
-                           search_from_forward_node, search_from_reverse_node,
-                           search_to_forward_node, search_to_reverse_node, source_phantom,
-                           target_phantom, total_distance_to_forward, total_distance_to_reverse,
-                           new_total_distance_to_forward, new_total_distance_to_reverse,
-                           packed_leg_to_forward, packed_leg_to_reverse);
+                    Search(forward_heap,
+                           reverse_heap,
+                           forward_core_heap,
+                           reverse_core_heap,
+                           search_from_forward_node,
+                           search_from_reverse_node,
+                           search_to_forward_node,
+                           search_to_reverse_node,
+                           source_phantom,
+                           target_phantom,
+                           total_distance_to_forward,
+                           total_distance_to_reverse,
+                           new_total_distance_to_forward,
+                           new_total_distance_to_reverse,
+                           packed_leg_to_forward,
+                           packed_leg_to_reverse);
                 }
             }
 
@@ -441,8 +485,11 @@ class ShortestPathRouting final
             packed_leg_to_reverse_begin.push_back(total_packed_path_to_reverse.size());
             BOOST_ASSERT(packed_leg_to_reverse_begin.size() == phantom_nodes_vector.size() + 1);
 
-            UnpackLegs(phantom_nodes_vector, total_packed_path_to_reverse,
-                       packed_leg_to_reverse_begin, total_distance_to_reverse, raw_route_data);
+            UnpackLegs(phantom_nodes_vector,
+                       total_packed_path_to_reverse,
+                       packed_leg_to_reverse_begin,
+                       total_distance_to_reverse,
+                       raw_route_data);
         }
         else
         {
@@ -450,8 +497,11 @@ class ShortestPathRouting final
             packed_leg_to_forward_begin.push_back(total_packed_path_to_forward.size());
             BOOST_ASSERT(packed_leg_to_forward_begin.size() == phantom_nodes_vector.size() + 1);
 
-            UnpackLegs(phantom_nodes_vector, total_packed_path_to_forward,
-                       packed_leg_to_forward_begin, total_distance_to_forward, raw_route_data);
+            UnpackLegs(phantom_nodes_vector,
+                       total_packed_path_to_forward,
+                       packed_leg_to_forward_begin,
+                       total_distance_to_forward,
+                       raw_route_data);
         }
     }
 };

include/engine/search_engine_data.hpp

@@ -3,8 +3,8 @@
 
 #include <boost/thread/tss.hpp>
 
-#include "util/typedefs.hpp"
 #include "util/binary_heap.hpp"
+#include "util/typedefs.hpp"
 
 namespace osrm
 {

include/engine/trip/trip_brute_force.hpp

@@ -1,18 +1,18 @@
 #ifndef TRIP_BRUTE_FORCE_HPP
 #define TRIP_BRUTE_FORCE_HPP
 
-#include "util/typedefs.hpp"
 #include "util/dist_table_wrapper.hpp"
 #include "util/simple_logger.hpp"
+#include "util/typedefs.hpp"
 
 #include "osrm/json_container.hpp"
 
-#include <cstdlib>
 #include <algorithm>
-#include <string>
+#include <cstdlib>
 #include <iterator>
-#include <vector>
 #include <limits>
+#include <string>
+#include <vector>
 
 namespace osrm
 {

include/engine/trip/trip_farthest_insertion.hpp

@@ -1,18 +1,18 @@
 #ifndef TRIP_FARTHEST_INSERTION_HPP
 #define TRIP_FARTHEST_INSERTION_HPP
 
-#include "util/typedefs.hpp"
 #include "util/dist_table_wrapper.hpp"
 #include "util/typedefs.hpp"
+#include "util/typedefs.hpp"
 
 #include "osrm/json_container.hpp"
 #include <boost/assert.hpp>
 
-#include <cstdlib>
 #include <algorithm>
+#include <cstdlib>
+#include <limits>
 #include <string>
 #include <vector>
-#include <limits>
 
 namespace osrm
 {
@@ -153,7 +153,6 @@ std::vector<NodeID> FarthestInsertionTrip(const NodeIDIterator &start,
     // 5. DONE!
     //////////////////////////////////////////////////////////////////////////////////////////////////
 
-
     // Guard against division-by-zero in the code path below.
     BOOST_ASSERT(number_of_locations > 0);
 

include/engine/trip/trip_nearest_neighbour.hpp

@@ -1,17 +1,17 @@
 #ifndef TRIP_NEAREST_NEIGHBOUR_HPP
 #define TRIP_NEAREST_NEIGHBOUR_HPP
 
-#include "util/typedefs.hpp"
-#include "util/simple_logger.hpp"
 #include "util/dist_table_wrapper.hpp"
+#include "util/simple_logger.hpp"
+#include "util/typedefs.hpp"
 
 #include "osrm/json_container.hpp"
 
-#include <cstdlib>
 #include <algorithm>
+#include <cstdlib>
+#include <limits>
 #include <string>
 #include <vector>
-#include <limits>
 
 namespace osrm
 {

include/extractor/edge_based_graph_factory.hpp

@@ -11,10 +11,10 @@
 #include "extractor/query_node.hpp"
 #include "extractor/restriction_map.hpp"
 
-#include "util/guidance/bearing_class.hpp"
-#include "util/guidance/entry_class.hpp"
 #include "extractor/guidance/turn_analysis.hpp"
 #include "extractor/guidance/turn_instruction.hpp"
+#include "util/guidance/bearing_class.hpp"
+#include "util/guidance/entry_class.hpp"
 
 #include "util/deallocating_vector.hpp"
 #include "util/name_table.hpp"

include/extractor/edge_based_node.hpp

@@ -21,8 +21,8 @@ struct EdgeBasedNode
 {
     EdgeBasedNode()
         : forward_segment_id{SPECIAL_SEGMENTID, false},
-          reverse_segment_id{SPECIAL_SEGMENTID, false}, u(SPECIAL_NODEID),
-          v(SPECIAL_NODEID), name_id(0), forward_packed_geometry_id(SPECIAL_EDGEID),
+          reverse_segment_id{SPECIAL_SEGMENTID, false}, u(SPECIAL_NODEID), v(SPECIAL_NODEID),
+          name_id(0), forward_packed_geometry_id(SPECIAL_EDGEID),
           reverse_packed_geometry_id(SPECIAL_EDGEID), component{INVALID_COMPONENTID, false},
           fwd_segment_position(std::numeric_limits<unsigned short>::max()),
           forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
@@ -42,15 +42,13 @@ struct EdgeBasedNode
                            unsigned short fwd_segment_position,
                            TravelMode forward_travel_mode,
                            TravelMode backward_travel_mode)
-        : forward_segment_id(forward_segment_id_),
-          reverse_segment_id(reverse_segment_id_), u(u), v(v), name_id(name_id),
-          forward_packed_geometry_id(forward_geometry_id_),
+        : forward_segment_id(forward_segment_id_), reverse_segment_id(reverse_segment_id_), u(u),
+          v(v), name_id(name_id), forward_packed_geometry_id(forward_geometry_id_),
           reverse_packed_geometry_id(reverse_geometry_id_),
           component{component_id, is_tiny_component}, fwd_segment_position(fwd_segment_position),
           forward_travel_mode(forward_travel_mode), backward_travel_mode(backward_travel_mode)
     {
-        BOOST_ASSERT(forward_segment_id.enabled ||
-                     reverse_segment_id.enabled);
+        BOOST_ASSERT(forward_segment_id.enabled || reverse_segment_id.enabled);
     }
 
     SegmentID forward_segment_id; // needed for edge-expanded graph

include/extractor/external_memory_node.hpp

@@ -25,15 +25,17 @@ struct ExternalMemoryNode : QueryNode
 
     static ExternalMemoryNode min_value()
     {
-        return ExternalMemoryNode(util::FixedLongitude(0), util::FixedLatitude(0), MIN_OSM_NODEID,
-                                  false, false);
+        return ExternalMemoryNode(
+            util::FixedLongitude(0), util::FixedLatitude(0), MIN_OSM_NODEID, false, false);
     }
 
     static ExternalMemoryNode max_value()
     {
         return ExternalMemoryNode(util::FixedLongitude(std::numeric_limits<int>::max()),
                                   util::FixedLatitude(std::numeric_limits<int>::max()),
-                                  MAX_OSM_NODEID, false, false);
+                                  MAX_OSM_NODEID,
+                                  false,
+                                  false);
     }
 
     bool barrier;

include/extractor/extraction_containers.hpp

@@ -1,11 +1,11 @@
 #ifndef EXTRACTION_CONTAINERS_HPP
 #define EXTRACTION_CONTAINERS_HPP
 
-#include "extractor/internal_extractor_edge.hpp"
-#include "extractor/first_and_last_segment_of_way.hpp"
-#include "extractor/scripting_environment.hpp"
 #include "extractor/external_memory_node.hpp"
+#include "extractor/first_and_last_segment_of_way.hpp"
+#include "extractor/internal_extractor_edge.hpp"
 #include "extractor/restriction.hpp"
+#include "extractor/scripting_environment.hpp"
 
 #include <stxxl/vector>
 #include <unordered_map>
@@ -58,8 +58,6 @@ class ExtractionContainers
 
     ExtractionContainers();
 
-    ~ExtractionContainers();
-
     void PrepareData(const std::string &output_file_name,
                      const std::string &restrictions_file_name,
                      const std::string &names_file_name,

include/extractor/extraction_helper_functions.hpp

@@ -1,8 +1,8 @@
 #ifndef EXTRACTION_HELPER_FUNCTIONS_HPP
 #define EXTRACTION_HELPER_FUNCTIONS_HPP
 
-#include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/phoenix.hpp>
+#include <boost/spirit/include/qi.hpp>
 
 #include <limits>
 #include <string>
@@ -19,8 +19,7 @@ namespace qi = boost::spirit::qi;
 
 template <typename Iterator> struct iso_8601_grammar : qi::grammar<Iterator, unsigned()>
 {
-    iso_8601_grammar()
-        : iso_8601_grammar::base_type(root)
+    iso_8601_grammar() : iso_8601_grammar::base_type(root)
 
     {
         using qi::_1;
@@ -38,50 +37,38 @@ template <typename Iterator> struct iso_8601_grammar : qi::grammar<Iterator, uns
         mm = uint2_p[_pass = bind([](unsigned x) { return x < 60; }, _1), _val = _1];
         ss = uint2_p[_pass = bind([](unsigned x) { return x < 60; }, _1), _val = _1];
 
-        osm_time
-            = (uint_p[_a = _1] >> eoi)                                                     [_val = _a * 60]
-            | (uint_p[_a = _1] >> ':' >> uint_p[_b = _1] >> eoi)                           [_val = _a * 3600 + _b * 60]
-            | (uint_p[_a = _1] >> ':' >> uint_p[_b = _1] >> ':' >> uint_p[_c = _1] >> eoi) [_val = _a * 3600 + _b * 60 + _c]
-            ;
+        osm_time = (uint_p[_a = _1] >> eoi)[_val = _a * 60] |
+                   (uint_p[_a = _1] >> ':' >> uint_p[_b = _1] >> eoi)[_val = _a * 3600 + _b * 60] |
+                   (uint_p[_a = _1] >> ':' >> uint_p[_b = _1] >> ':' >> uint_p[_c = _1] >>
+                    eoi)[_val = _a * 3600 + _b * 60 + _c];
 
-        alternative_time
-            = ('T' >> hh[_a = _1] >> mm[_b = _1] >> ss[_c = _1])                        [_val = _a * 3600 + _b * 60 + _c]
-            ;
+        alternative_time =
+            ('T' >> hh[_a = _1] >> mm[_b = _1] >> ss[_c = _1])[_val = _a * 3600 + _b * 60 + _c];
 
-        extended_time
-            = ('T' >> hh[_a = _1] >> ':' >> mm[_b = _1] >> ':' >> ss[_c = _1])          [_val = _a * 3600 + _b * 60 + _c]
-            ;
+        extended_time = ('T' >> hh[_a = _1] >> ':' >> mm[_b = _1] >> ':' >>
+                         ss[_c = _1])[_val = _a * 3600 + _b * 60 + _c];
 
-        standard_time
-            = ('T'
-               >> -(uint_ >> char_("Hh"))[_a = _1]
-               >> -(uint_ >> char_("Mm"))[_b = _1]
-               >> -(uint_ >> char_("Ss"))[_c = _1])                                     [_val = _a * 3600 + _b * 60 + _c]
-            ;
+        standard_time =
+            ('T' >> -(uint_ >> char_("Hh"))[_a = _1] >> -(uint_ >> char_("Mm"))[_b = _1] >>
+             -(uint_ >> char_("Ss"))[_c = _1])[_val = _a * 3600 + _b * 60 + _c];
 
-        standard_date
-            = (uint_ >> char_("Dd"))                                                    [_val = _1 * 86400]
-            ;
+        standard_date = (uint_ >> char_("Dd"))[_val = _1 * 86400];
 
-        standard_week
-            = (uint_ >> char_("Ww"))                                                    [_val = _1 * 604800]
-            ;
+        standard_week = (uint_ >> char_("Ww"))[_val = _1 * 604800];
 
-        iso_period
-            = osm_time                                                                  [_val = _1]
-            | ('P' >> standard_week >> eoi)                                             [_val = _1]
-            | ('P' >> ( alternative_time[_a = 0, _b = _1]
-                      | extended_time[_a = 0, _b = _1]
-                      | (eps[_a = 0, _b = 0] >> -standard_date[_a = _1] >> -standard_time[_b = _1] ) )
-                   >> eoi)                                                              [_val = _a + _b]
-            ;
+        iso_period =
+            osm_time[_val = _1] | ('P' >> standard_week >> eoi)[_val = _1] |
+            ('P' >> (alternative_time[_a = 0, _b = _1] | extended_time[_a = 0, _b = _1] |
+                     (eps[_a = 0, _b = 0] >> -standard_date[_a = _1] >> -standard_time[_b = _1])) >>
+             eoi)[_val = _a + _b];
 
         root = iso_period;
     }
 
     qi::rule<Iterator, unsigned()> root;
     qi::rule<Iterator, unsigned(), qi::locals<unsigned, unsigned>> iso_period;
-    qi::rule<Iterator, unsigned(), qi::locals<unsigned, unsigned, unsigned>> osm_time, standard_time, alternative_time, extended_time;
+    qi::rule<Iterator, unsigned(), qi::locals<unsigned, unsigned, unsigned>> osm_time,
+        standard_time, alternative_time, extended_time;
     qi::rule<Iterator, unsigned()> standard_date, standard_week;
     qi::rule<Iterator, unsigned()> hh, mm, ss;
 
@@ -111,7 +98,6 @@ inline unsigned parseDuration(const std::string &s)
 
     return !s.empty() && iter == s.end() ? duration : std::numeric_limits<unsigned>::max();
 }
-
 }
 }
 

include/extractor/extraction_way.hpp

@@ -31,6 +31,8 @@ struct ExtractionWay
         is_startpoint = true;
         is_access_restricted = false;
         name.clear();
+        pronunciation.clear();
+        destinations.clear();
         forward_travel_mode = TRAVEL_MODE_INACCESSIBLE;
         backward_travel_mode = TRAVEL_MODE_INACCESSIBLE;
     }
@@ -46,6 +48,8 @@ struct ExtractionWay
     double backward_speed;
     double duration;
     std::string name;
+    std::string pronunciation;
+    std::string destinations;
     bool roundabout;
     bool is_access_restricted;
     bool is_startpoint;

include/extractor/extractor_callbacks.hpp

@@ -2,6 +2,7 @@
 #define EXTRACTOR_CALLBACKS_HPP
 
 #include "util/typedefs.hpp"
+#include <boost/functional/hash.hpp>
 #include <boost/optional/optional_fwd.hpp>
 
 #include <string>
@@ -33,8 +34,10 @@ struct ExtractionWay;
 class ExtractorCallbacks
 {
   private:
-    // used to deduplicate street names: actually maps to name ids
-    std::unordered_map<std::string, NodeID> string_map;
+    // used to deduplicate street names and street destinations: actually maps to name ids
+    using MapKey = std::pair<std::string, std::string>;
+    using MapVal = unsigned;
+    std::unordered_map<MapKey, MapVal, boost::hash<MapKey>> string_map;
     ExtractionContainers &external_memory;
 
   public:

include/extractor/extractor_config.hpp

@@ -30,8 +30,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <boost/filesystem/path.hpp>
 
-#include <string>
 #include <array>
+#include <string>
 
 namespace osrm
 {
@@ -72,7 +72,7 @@ struct ExtractorConfig
         edge_penalty_path = basepath + ".osrm.edge_penalties";
         edge_based_node_weights_output_path = basepath + ".osrm.enw";
         profile_properties_output_path = basepath + ".osrm.properties";
-        intersection_class_data_output_path = basepath  + ".osrm.icd";
+        intersection_class_data_output_path = basepath + ".osrm.icd";
     }
 
     boost::filesystem::path config_file_path;

include/extractor/guidance/classification_data.hpp

@@ -47,6 +47,17 @@ inline bool isRampClass(const FunctionalRoadClass road_class)
            road_class == FunctionalRoadClass::TRUNK_LINK;
 }
 
+// Links are usually smaller than ramps, but are sometimes tagged
+// as MOTORWAY_LINK if they exit/enter a motorway/trunk road.
+inline bool isLinkClass(const FunctionalRoadClass road_class)
+{
+    return road_class == FunctionalRoadClass::MOTORWAY_LINK ||
+           road_class == FunctionalRoadClass::TRUNK_LINK ||
+           road_class == FunctionalRoadClass::PRIMARY_LINK ||
+           road_class == FunctionalRoadClass::SECONDARY_LINK ||
+           road_class == FunctionalRoadClass::TERTIARY_LINK;
+}
+
 // TODO augment this with all data required for guidance generation
 struct RoadClassificationData
 {

include/extractor/guidance/constants.hpp

@@ -20,12 +20,13 @@ 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 = 20.;
 const double constexpr DISTINCTION_RATIO = 2;
-const unsigned constexpr INVALID_NAME_ID = 0;
 
-const double constexpr MAX_ROUNDABOUT_INTERSECTION_RADIUS =  5;
+const double constexpr MAX_ROUNDABOUT_INTERSECTION_RADIUS = 5;
 const double constexpr MAX_ROUNDABOUT_RADIUS = 15; // 30 m diameter as final distinction
 const double constexpr INCREASES_BY_FOURTY_PERCENT = 1.4;
 
+const int constexpr MAX_SLIPROAD_THRESHOLD = 250;
+
 } // namespace guidance
 } // namespace extractor
 } // namespace osrm

include/extractor/guidance/motorway_handler.hpp

@@ -2,6 +2,7 @@
 #define OSRM_EXTRACTOR_GUIDANCE_MOTORWAY_HANDLER_HPP_
 
 #include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/intersection_generator.hpp"
 #include "extractor/guidance/intersection_handler.hpp"
 #include "extractor/query_node.hpp"
 
@@ -25,7 +26,8 @@ class MotorwayHandler : public IntersectionHandler
     MotorwayHandler(const util::NodeBasedDynamicGraph &node_based_graph,
                     const std::vector<QueryNode> &node_info_list,
                     const util::NameTable &name_table,
-                    const SuffixTable &street_name_suffix_table);
+                    const SuffixTable &street_name_suffix_table,
+                    const IntersectionGenerator &intersection_generator);
     ~MotorwayHandler() override final;
 
     // check whether the handler can actually handle the intersection
@@ -39,10 +41,14 @@ class MotorwayHandler : public IntersectionHandler
                             Intersection intersection) const override final;
 
   private:
+    Intersection handleSliproads(const NodeID intersection_node_id,
+                                 Intersection intersection) const;
     Intersection fromMotorway(const EdgeID via_edge, Intersection intersection) const;
     Intersection fromRamp(const EdgeID via_edge, Intersection intersection) const;
 
     Intersection fallback(Intersection intersection) const;
+
+    const IntersectionGenerator &intersection_generator;
 };
 
 } // namespace guidance

include/extractor/guidance/roundabout_type.hpp

@@ -9,10 +9,10 @@ namespace guidance
 {
 enum class RoundaboutType
 {
-    None,                   // not a roundabout
-    Roundabout,             // standard roundabout
-    Rotary,                 // traffic circle (large roundabout) with dedicated name
-    RoundaboutIntersection  // small roundabout with distinct turns, handled as intersection
+    None,                  // not a roundabout
+    Roundabout,            // standard roundabout
+    Rotary,                // traffic circle (large roundabout) with dedicated name
+    RoundaboutIntersection // small roundabout with distinct turns, handled as intersection
 };
 } /* namespace guidance */
 } /* namespace extractor */

include/extractor/guidance/toolkit.hpp

@@ -70,7 +70,8 @@ getCoordinateFromCompressedRange(util::Coordinate current_coordinate,
     };
 
     for (auto compressed_geometry_itr = compressed_geometry_begin;
-         compressed_geometry_itr != compressed_geometry_end; ++compressed_geometry_itr)
+         compressed_geometry_itr != compressed_geometry_end;
+         ++compressed_geometry_itr)
     {
         const auto next_coordinate =
             extractCoordinateFromNode(query_nodes[compressed_geometry_itr->node_id]);
@@ -82,7 +83,8 @@ getCoordinateFromCompressedRange(util::Coordinate current_coordinate,
         if (distance_to_next_coordinate >= detail::DESIRED_SEGMENT_LENGTH)
             return util::coordinate_calculation::interpolateLinear(
                 getFactor(distance_to_current_coordinate, distance_to_next_coordinate),
-                current_coordinate, next_coordinate);
+                current_coordinate,
+                next_coordinate);
 
         // prepare for next iteration
         current_coordinate = next_coordinate;
@@ -98,7 +100,8 @@ getCoordinateFromCompressedRange(util::Coordinate current_coordinate,
         distance_to_next_coordinate >= detail::DESIRED_SEGMENT_LENGTH)
         return util::coordinate_calculation::interpolateLinear(
             getFactor(distance_to_current_coordinate, distance_to_next_coordinate),
-            current_coordinate, final_coordinate);
+            current_coordinate,
+            final_coordinate);
     else
         return final_coordinate;
 }
@@ -280,10 +283,14 @@ inline double getTurnConfidence(const double angle, TurnInstruction instruction)
 // swaps left <-> right modifier types
 inline DirectionModifier::Enum mirrorDirectionModifier(const DirectionModifier::Enum modifier)
 {
-    const constexpr DirectionModifier::Enum results[] = {
-        DirectionModifier::UTurn,      DirectionModifier::SharpLeft, DirectionModifier::Left,
-        DirectionModifier::SlightLeft, DirectionModifier::Straight,  DirectionModifier::SlightRight,
-        DirectionModifier::Right,      DirectionModifier::SharpRight};
+    const constexpr DirectionModifier::Enum results[] = {DirectionModifier::UTurn,
+                                                         DirectionModifier::SharpLeft,
+                                                         DirectionModifier::Left,
+                                                         DirectionModifier::SlightLeft,
+                                                         DirectionModifier::Straight,
+                                                         DirectionModifier::SlightRight,
+                                                         DirectionModifier::Right,
+                                                         DirectionModifier::SharpRight};
     return results[modifier];
 }
 
@@ -380,8 +387,10 @@ inline bool requiresNameAnnounced(const std::string &from,
                     return false;
                 if (!checkTable(first_prefix_and_suffixes.first))
                     return false;
-                return !first.compare(first_prefix_and_suffixes.first.length(), std::string::npos,
-                                      second, second_prefix_and_suffixes.first.length(),
+                return !first.compare(first_prefix_and_suffixes.first.length(),
+                                      std::string::npos,
+                                      second,
+                                      second_prefix_and_suffixes.first.length(),
                                       std::string::npos);
             }();
 
@@ -390,8 +399,10 @@ inline bool requiresNameAnnounced(const std::string &from,
                     return false;
                 if (!checkTable(first_prefix_and_suffixes.second))
                     return false;
-                return !first.compare(0, first.length() - first_prefix_and_suffixes.second.length(),
-                                      second, 0,
+                return !first.compare(0,
+                                      first.length() - first_prefix_and_suffixes.second.length(),
+                                      second,
+                                      0,
                                       second.length() - second_prefix_and_suffixes.second.length());
             }();
 
@@ -421,8 +432,8 @@ inline int getPriority(const FunctionalRoadClass road_class)
     // The road priorities indicate which roads can bee seen as more or less equal.
     // They are used in Fork-Discovery. Possibly should be moved to profiles post v5?
     // A fork can happen between road types that are at most 1 priority apart from each other
-    const constexpr int road_priority[] = {10, 0, 10, 2,  10, 4,  10, 6,
-                                           10, 8, 10, 11, 10, 12, 10, 14};
+    const constexpr int road_priority[] = {
+        10, 0, 10, 2, 10, 4, 10, 6, 10, 8, 10, 11, 10, 12, 10, 14};
     return road_priority[static_cast<int>(road_class)];
 }
 
@@ -441,10 +452,14 @@ inline bool canBeSeenAsFork(const FunctionalRoadClass first, const FunctionalRoa
 // turn and vice versa.
 inline ConnectedRoad mirror(ConnectedRoad road)
 {
-    const constexpr DirectionModifier::Enum mirrored_modifiers[] = {
-        DirectionModifier::UTurn,      DirectionModifier::SharpLeft, DirectionModifier::Left,
-        DirectionModifier::SlightLeft, DirectionModifier::Straight,  DirectionModifier::SlightRight,
-        DirectionModifier::Right,      DirectionModifier::SharpRight};
+    const constexpr DirectionModifier::Enum mirrored_modifiers[] = {DirectionModifier::UTurn,
+                                                                    DirectionModifier::SharpLeft,
+                                                                    DirectionModifier::Left,
+                                                                    DirectionModifier::SlightLeft,
+                                                                    DirectionModifier::Straight,
+                                                                    DirectionModifier::SlightRight,
+                                                                    DirectionModifier::Right,
+                                                                    DirectionModifier::SharpRight};
 
     if (angularDeviation(road.turn.angle, 0) > std::numeric_limits<double>::epsilon())
     {

include/extractor/guidance/turn_analysis.hpp

@@ -59,6 +59,9 @@ class TurnAnalysis
     // Utility function, setting basic turn types. Prepares for normal turn handling.
     Intersection
     setTurnTypes(const NodeID from, const EdgeID via_edge, Intersection intersection) const;
+
+    Intersection handleSliproads(const NodeID intersection_node_id,
+                                 Intersection intersection) const;
 }; // class TurnAnalysis
 
 } // namespace guidance

include/extractor/guidance/turn_classification.hpp

@@ -1,23 +1,21 @@
 #ifndef OSRM_GUIDANCE_TURN_CLASSIFICATION_HPP_
 #define OSRM_GUIDANCE_TURN_CLASSIFICATION_HPP_
 
+#include "extractor/compressed_edge_container.hpp"
 #include "extractor/guidance/intersection.hpp"
 #include "extractor/guidance/toolkit.hpp"
-#include "extractor/compressed_edge_container.hpp"
 #include "extractor/query_node.hpp"
 
-#include "util/guidance/entry_class.hpp"
-#include "util/guidance/bearing_class.hpp"
 #include "util/coordinate.hpp"
+#include "util/guidance/bearing_class.hpp"
+#include "util/guidance/entry_class.hpp"
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"
 
-
-
 #include <algorithm>
 #include <cstddef>
-#include <vector>
 #include <utility>
+#include <vector>
 
 namespace osrm
 {
@@ -26,7 +24,7 @@ namespace extractor
 namespace guidance
 {
 
-std::pair<util::guidance::EntryClass,util::guidance::BearingClass>
+std::pair<util::guidance::EntryClass, util::guidance::BearingClass>
 classifyIntersection(NodeID nid,
                      const Intersection &intersection,
                      const util::NodeBasedDynamicGraph &node_based_graph,

include/extractor/guidance/turn_instruction.hpp

@@ -20,7 +20,6 @@ namespace detail
 const constexpr uint8_t num_direction_modifiers = 8;
 } // detail
 
-
 // direction modifiers based on angle
 namespace DirectionModifier
 {
@@ -38,31 +37,36 @@ const constexpr Enum SharpLeft = 7;
 namespace TurnType
 {
 typedef std::uint8_t Enum;
-const constexpr Enum Invalid = 0;                             // no valid turn instruction
-const constexpr Enum NewName = 1;                             // no turn, but name changes
-const constexpr Enum Continue = 2;                            // remain on a street
-const constexpr Enum Turn = 3;                                // basic turn
-const constexpr Enum Merge = 4;                               // merge onto a street
-const constexpr Enum OnRamp = 5;                              // special turn (highway ramp on-ramps)
-const constexpr Enum OffRamp = 6;                             // special turn, highway exit
-const constexpr Enum Fork = 7;                                // fork road splitting up
-const constexpr Enum EndOfRoad = 8;                           // T intersection
-const constexpr Enum Notification = 9;                        // Travel Mode Changes, Restrictions apply...
-const constexpr Enum EnterRoundabout = 10;                    // Entering a small Roundabout
-const constexpr Enum EnterAndExitRoundabout = 11;             // Touching a roundabout
-const constexpr Enum EnterRotary = 12;                        // Enter a rotary
-const constexpr Enum EnterAndExitRotary = 13;                 // Touching a rotary
-const constexpr Enum EnterRoundaboutIntersection = 14;        // Entering a small Roundabout
+const constexpr Enum Invalid = 0;                      // no valid turn instruction
+const constexpr Enum NewName = 1;                      // no turn, but name changes
+const constexpr Enum Continue = 2;                     // remain on a street
+const constexpr Enum Turn = 3;                         // basic turn
+const constexpr Enum Merge = 4;                        // merge onto a street
+const constexpr Enum OnRamp = 5;                       // special turn (highway ramp on-ramps)
+const constexpr Enum OffRamp = 6;                      // special turn, highway exit
+const constexpr Enum Fork = 7;                         // fork road splitting up
+const constexpr Enum EndOfRoad = 8;                    // T intersection
+const constexpr Enum Notification = 9;                 // Travel Mode Changes, Restrictions apply...
+const constexpr Enum EnterRoundabout = 10;             // Entering a small Roundabout
+const constexpr Enum EnterAndExitRoundabout = 11;      // Touching a roundabout
+const constexpr Enum EnterRotary = 12;                 // Enter a rotary
+const constexpr Enum EnterAndExitRotary = 13;          // Touching a rotary
+const constexpr Enum EnterRoundaboutIntersection = 14; // Entering a small Roundabout
 const constexpr Enum EnterAndExitRoundaboutIntersection = 15; // Touching a roundabout
-const constexpr Enum NoTurn = 16;                             // end of segment without turn/middle of a segment
-const constexpr Enum Suppressed = 17;                         // location that suppresses a turn
-const constexpr Enum EnterRoundaboutAtExit = 18;              // Entering a small Roundabout at a countable exit
-const constexpr Enum ExitRoundabout = 19;                     // Exiting a small Roundabout
-const constexpr Enum EnterRotaryAtExit = 20;                  // Enter A Rotary at a countable exit
-const constexpr Enum ExitRotary = 21;                         // Exit a rotary
-const constexpr Enum EnterRoundaboutIntersectionAtExit = 22;  // Entering a small Roundabout at a countable exit
-const constexpr Enum ExitRoundaboutIntersection = 23;         // Exiting a small Roundabout
-const constexpr Enum StayOnRoundabout = 24;                   // Continue on Either a small or a large Roundabout
+
+// Values below here are silent instructions
+const constexpr Enum NoTurn = 16;                // end of segment without turn/middle of a segment
+const constexpr Enum Suppressed = 17;            // location that suppresses a turn
+const constexpr Enum EnterRoundaboutAtExit = 18; // Entering a small Roundabout at a countable exit
+const constexpr Enum ExitRoundabout = 19;        // Exiting a small Roundabout
+const constexpr Enum EnterRotaryAtExit = 20;     // Enter A Rotary at a countable exit
+const constexpr Enum ExitRotary = 21;            // Exit a rotary
+const constexpr Enum EnterRoundaboutIntersectionAtExit =
+    22; // Entering a small Roundabout at a countable exit
+const constexpr Enum ExitRoundaboutIntersection = 23; // Exiting a small Roundabout
+const constexpr Enum StayOnRoundabout = 24; // Continue on Either a small or a large Roundabout
+const constexpr Enum Sliproad =
+    25; // Something that looks like a ramp, but is actually just a small sliproad
 }
 
 // turn angle in 1.40625 degree -> 128 == 180 degree
@@ -87,7 +91,8 @@ struct TurnInstruction
         return TurnInstruction(TurnType::NoTurn, DirectionModifier::UTurn);
     }
 
-    static TurnInstruction REMAIN_ROUNDABOUT(const RoundaboutType, const DirectionModifier::Enum modifier)
+    static TurnInstruction REMAIN_ROUNDABOUT(const RoundaboutType,
+                                             const DirectionModifier::Enum modifier)
     {
         return TurnInstruction(TurnType::StayOnRoundabout, modifier);
     }
@@ -96,7 +101,9 @@ struct TurnInstruction
                                             const DirectionModifier::Enum modifier)
     {
         const constexpr TurnType::Enum enter_instruction[] = {
-            TurnType::Invalid, TurnType::EnterRoundabout, TurnType::EnterRotary,
+            TurnType::Invalid,
+            TurnType::EnterRoundabout,
+            TurnType::EnterRotary,
             TurnType::EnterRoundaboutIntersection};
         return {enter_instruction[static_cast<int>(roundabout_type)], modifier};
     }
@@ -104,9 +111,10 @@ struct TurnInstruction
     static TurnInstruction EXIT_ROUNDABOUT(const RoundaboutType roundabout_type,
                                            const DirectionModifier::Enum modifier)
     {
-        const constexpr TurnType::Enum exit_instruction[] = {TurnType::Invalid, TurnType::ExitRoundabout,
-                                                       TurnType::ExitRotary,
-                                                       TurnType::ExitRoundaboutIntersection};
+        const constexpr TurnType::Enum exit_instruction[] = {TurnType::Invalid,
+                                                             TurnType::ExitRoundabout,
+                                                             TurnType::ExitRotary,
+                                                             TurnType::ExitRoundaboutIntersection};
         return {exit_instruction[static_cast<int>(roundabout_type)], modifier};
     }
 
@@ -114,7 +122,9 @@ struct TurnInstruction
                                                      const DirectionModifier::Enum modifier)
     {
         const constexpr TurnType::Enum exit_instruction[] = {
-            TurnType::Invalid, TurnType::EnterAndExitRoundabout, TurnType::EnterAndExitRotary,
+            TurnType::Invalid,
+            TurnType::EnterAndExitRoundabout,
+            TurnType::EnterAndExitRotary,
             TurnType::EnterAndExitRoundaboutIntersection};
         return {exit_instruction[static_cast<int>(roundabout_type)], modifier};
     }
@@ -123,7 +133,9 @@ struct TurnInstruction
                                                     const DirectionModifier::Enum modifier)
     {
         const constexpr TurnType::Enum enter_instruction[] = {
-            TurnType::Invalid, TurnType::EnterRoundaboutAtExit, TurnType::EnterRotaryAtExit,
+            TurnType::Invalid,
+            TurnType::EnterRoundaboutAtExit,
+            TurnType::EnterRotaryAtExit,
             TurnType::EnterRoundaboutIntersectionAtExit};
         return {enter_instruction[static_cast<int>(roundabout_type)], modifier};
     }

include/extractor/internal_extractor_edge.hpp

@@ -1,15 +1,15 @@
 #ifndef INTERNAL_EXTRACTOR_EDGE_HPP
 #define INTERNAL_EXTRACTOR_EDGE_HPP
 
-#include "util/typedefs.hpp"
-#include "extractor/travel_mode.hpp"
 #include "extractor/node_based_edge.hpp"
+#include "extractor/travel_mode.hpp"
+#include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
 
+#include "extractor/guidance/classification_data.hpp"
 #include "osrm/coordinate.hpp"
 #include <utility>
-#include "extractor/guidance/classification_data.hpp"
 
 namespace osrm
 {
@@ -32,8 +32,7 @@ struct InternalExtractorEdge
 
         WeightData() : duration(0.0), type(WeightType::INVALID) {}
 
-        union
-        {
+        union {
             double duration;
             double speed;
         };
@@ -94,14 +93,32 @@ struct InternalExtractorEdge
     // necessary static util functions for stxxl's sorting
     static InternalExtractorEdge min_osm_value()
     {
-        return InternalExtractorEdge(MIN_OSM_NODEID, MIN_OSM_NODEID, 0, WeightData(), false, false,
-                                     false, false, true, TRAVEL_MODE_INACCESSIBLE, false,
+        return InternalExtractorEdge(MIN_OSM_NODEID,
+                                     MIN_OSM_NODEID,
+                                     0,
+                                     WeightData(),
+                                     false,
+                                     false,
+                                     false,
+                                     false,
+                                     true,
+                                     TRAVEL_MODE_INACCESSIBLE,
+                                     false,
                                      guidance::RoadClassificationData());
     }
     static InternalExtractorEdge max_osm_value()
     {
-        return InternalExtractorEdge(MAX_OSM_NODEID, MAX_OSM_NODEID, 0, WeightData(), false, false,
-                                     false, false, true, TRAVEL_MODE_INACCESSIBLE, false,
+        return InternalExtractorEdge(MAX_OSM_NODEID,
+                                     MAX_OSM_NODEID,
+                                     0,
+                                     WeightData(),
+                                     false,
+                                     false,
+                                     false,
+                                     false,
+                                     true,
+                                     TRAVEL_MODE_INACCESSIBLE,
+                                     false,
                                      guidance::RoadClassificationData());
     }
 

include/extractor/original_edge_data.hpp

@@ -27,8 +27,7 @@ struct OriginalEdgeData
 
     OriginalEdgeData()
         : via_node(std::numeric_limits<unsigned>::max()),
-          name_id(std::numeric_limits<unsigned>::max()),
-          entry_classid(INVALID_ENTRY_CLASSID),
+          name_id(std::numeric_limits<unsigned>::max()), entry_classid(INVALID_ENTRY_CLASSID),
           turn_instruction(guidance::TurnInstruction::INVALID()),
           travel_mode(TRAVEL_MODE_INACCESSIBLE)
     {

include/extractor/profile_properties.hpp

@@ -11,24 +11,19 @@ namespace extractor
 struct ProfileProperties
 {
     ProfileProperties()
-        : traffic_signal_penalty(0), u_turn_penalty(0), continue_straight_at_waypoint(true), use_turn_restrictions(false)
+        : traffic_signal_penalty(0), u_turn_penalty(0), continue_straight_at_waypoint(true),
+          use_turn_restrictions(false)
     {
     }
 
-    double GetUturnPenalty() const
-    {
-        return u_turn_penalty / 10.;
-    }
+    double GetUturnPenalty() const { return u_turn_penalty / 10.; }
 
     void SetUturnPenalty(const double u_turn_penalty_)
     {
         u_turn_penalty = boost::numeric_cast<int>(u_turn_penalty_ * 10.);
     }
 
-    double GetTrafficSignalPenalty() const
-    {
-        return traffic_signal_penalty / 10.;
-    }
+    double GetTrafficSignalPenalty() const { return traffic_signal_penalty / 10.; }
 
     void SetTrafficSignalPenalty(const double traffic_signal_penalty_)
     {

include/extractor/query_node.hpp

@@ -36,13 +36,15 @@ struct QueryNode
     static QueryNode min_value()
     {
         return QueryNode(util::FixedLongitude(-180 * COORDINATE_PRECISION),
-                         util::FixedLatitude(-90 * COORDINATE_PRECISION), MIN_OSM_NODEID);
+                         util::FixedLatitude(-90 * COORDINATE_PRECISION),
+                         MIN_OSM_NODEID);
     }
 
     static QueryNode max_value()
     {
         return QueryNode(util::FixedLongitude(180 * COORDINATE_PRECISION),
-                         util::FixedLatitude(90 * COORDINATE_PRECISION), MAX_OSM_NODEID);
+                         util::FixedLatitude(90 * COORDINATE_PRECISION),
+                         MAX_OSM_NODEID);
     }
 };
 }

include/extractor/raster_source.hpp

@@ -1,18 +1,18 @@
 #ifndef RASTER_SOURCE_HPP
 #define RASTER_SOURCE_HPP
 
-#include "util/exception.hpp"
 #include "util/coordinate.hpp"
+#include "util/exception.hpp"
 
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
-#include <boost/spirit/include/qi_int.hpp>
-#include <boost/spirit/include/qi.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/assert.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/qi_int.hpp>
 
-#include <unordered_map>
 #include <iterator>
+#include <unordered_map>
 
 namespace osrm
 {

include/extractor/restriction.hpp

@@ -12,8 +12,7 @@ namespace extractor
 
 struct TurnRestriction
 {
-    union WayOrNode
-    {
+    union WayOrNode {
         OSMNodeID_weak node;
         OSMEdgeID_weak way;
     };

include/extractor/restriction_map.hpp

@@ -76,7 +76,7 @@ namespace extractor
 class RestrictionMap
 {
   public:
-    RestrictionMap() : m_count(0){}
+    RestrictionMap() : m_count(0) {}
     RestrictionMap(const std::vector<TurnRestriction> &restriction_list);
 
     // Replace end v with w in each turn restriction containing u as via node