Bump version to 5.20.0-rc.2

Pre-calculate distance values

.travis.yml

@@ -13,6 +13,7 @@ notifications:
 branches:
   only:
     - master
+    - danpat_table_noroute_estimate
     # enable building tags
     - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
 
@@ -296,7 +297,7 @@ before_install:
     fi
   - |
     if [[ ! -f $(which yarn) ]]; then
-      npm install -g yarn
+      npm install -g yarn@1.11.1
     fi
   - export PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
   - export PUBLISH=$([[ "${TRAVIS_TAG:-}" == "v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off")
@@ -365,7 +366,7 @@ install:
 script:
   - if [[ $TARGET_ARCH == armhf ]] ; then echo "Skip tests for $TARGET_ARCH" && exit 0 ; fi
   - make -C test/data benchmark
-  # - ./example/build/osrm-example test/data/mld/monaco.osrm
+  - ./example/build/osrm-example test/data/mld/monaco.osrm
   # All tests assume to be run from the build directory
   - pushd ${OSRM_BUILD_DIR}
   - ./unit_tests/library-tests

CHANGELOG.md

@@ -1,14 +1,24 @@
 # UNRELEASED
   - Changes from 5.19.0:
+    - Table:
+      - CHANGED: switch to pre-calculated distances for table responses for large speedup and 10% memory increase. [#5251](https://github.com/Project-OSRM/osrm-backend/pull/5251)
     - Features:
-      - ADDED: direct mmapping of datafiles is now supported via the `-mmap` switch. [#5242](https://github.com/Project-OSRM/osrm-backend/pull/5242)
+      - ADDED: direct mmapping of datafiles is now supported via the `--mmap` switch. [#5242](https://github.com/Project-OSRM/osrm-backend/pull/5242)
       - REMOVED: the previous `--memory_file` switch is now deprecated and will fallback to `--mmap` [#5242](https://github.com/Project-OSRM/osrm-backend/pull/5242)
+    - Windows:
+      - FIXED: Windows builds again. [#5249](https://github.com/Project-OSRM/osrm-backend/pull/5249)
 
 # 5.19.0
   - Changes from 5.18.0:
     - Optimizations:
       - CHANGED: Use Grisu2 for serializing floating point numbers. [#5188](https://github.com/Project-OSRM/osrm-backend/pull/5188)
       - ADDED: Node bindings can return pre-rendered JSON buffer. [#5189](https://github.com/Project-OSRM/osrm-backend/pull/5189)
+    - Profiles:
+      - CHANGED: Bicycle profile now blacklists barriers instead of whitelisting them [#5076
+](https://github.com/Project-OSRM/osrm-backend/pull/5076/)
+      - CHANGED: Foot profile now blacklists barriers instead of whitelisting them [#5077
+](https://github.com/Project-OSRM/osrm-backend/pull/5077/)
+      - CHANGED: Support maxlength and maxweight in car profile [#5101](https://github.com/Project-OSRM/osrm-backend/pull/5101]
     - Bugfixes:
       - FIXED: collapsing of ExitRoundabout instructions [#5114](https://github.com/Project-OSRM/osrm-backend/issues/5114)
     - Misc:

docs/nodejs/api.md

@@ -25,7 +25,9 @@ var osrm = new OSRM('network.osrm');
                Make sure you prepared the dataset with the correct toolchain.
     -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
                This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
-    -   `options.memory_file` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Path to a file on disk to store the memory using mmap.
+    -   `options.memory_file` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** *DEPRECATED*
+               Old behaviour: Path to a file on disk to store the memory using mmap.  Current behaviour: setting this value is the same as setting `mmap_memory: true`.
+    -   `options.mmap_memory` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Map on-disk files to virtual memory addresses (mmap), rather than loading into RAM.
     -   `options.path` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** The path to the `.osrm` files. This is mutually exclusive with setting {options.shared_memory} to true.
     -   `options.max_locations_trip` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in trip query (default: unlimited).
     -   `options.max_locations_viaroute` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in viaroute query (default: unlimited).
@@ -56,7 +58,7 @@ Returns the fastest route between two or more coordinates while visiting the way
     -   `options.continue_straight` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** 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.
     -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
                          `null`/`true`/`false`
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
+-   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
 
@@ -88,7 +90,7 @@ Note: `coordinates` in the general options only supports a single `{longitude},{
     -   `options.number` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** Number of nearest segments that should be returned.
         Must be an integer greater than or equal to `1`. (optional, default `1`)
     -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
+-   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
 
@@ -127,7 +129,7 @@ tables. Optionally returns distance table.
     -   `options.destinations` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer <
         #coordinates`) to use location with given index as destination. Default is to use all.
     -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
+-   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
 
@@ -167,7 +169,7 @@ and what weights they have applied.
 -   `ZXY` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** an array consisting of `x`, `y`, and `z` values representing tile coordinates like
            [wiki.openstreetmap.org/wiki/Slippy_map_tilenames](https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames)
            and are supported by vector tile viewers like [Mapbox GL JS](https://www.mapbox.com/mapbox-gl-js/api/).
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
+-   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
 
@@ -204,7 +206,7 @@ if they can not be matched successfully.
     -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy. Can be `null` for default value `5` meters or `double >= 0`.
     -   `options.gaps` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Allows the input track splitting based on huge timestamp gaps between points. Either `split` or `ignore` (optional, default `split`).
     -   `options.tidy` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Allows the input track modification to obtain better matching quality for noisy tracks (optional, default `false`).
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
+-   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
 
@@ -268,7 +270,7 @@ Right now, the following combinations are possible:
     -   `options.source` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route starts at `any` or `first` coordinate. (optional, default `any`)
     -   `options.destination` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route ends at `any` or `last` coordinate. (optional, default `any`)
     -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
+-   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
 
@@ -322,16 +324,14 @@ osrm.route(options, { format: "json_buffer" }, function(err, response) {
 
 ## Responses
 
-Responses
-
 ### Route
 
 Represents a route through (potentially multiple) waypoints.
 
 **Parameters**
 
--   `exteral` **documentation** in
-    [`osrm-backend`](../http.md#route)
+-   **documentation** in
+    [`osrm-backend`](../http.md#route-object)
 
 ### RouteLeg
 
@@ -339,8 +339,8 @@ Represents a route between two waypoints.
 
 **Parameters**
 
--   `exteral` **documentation** in
-    [`osrm-backend`](../http.md#routeleg)
+-   **documentation** in
+    [`osrm-backend`](../http.md#routeleg-object)
 
 ### RouteStep
 
@@ -349,15 +349,15 @@ single way to the subsequent step.
 
 **Parameters**
 
--   `exteral` **documentation** in
-    [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#routestep)
+-   **documentation** in
+    [`osrm-backend`](../http.md#routestep-object)
 
 ### StepManeuver
 
 **Parameters**
 
--   `exteral` **documentation** in
-    [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#stepmaneuver)
+-   **documentation** in
+    [`osrm-backend`](../http.md#stepmaneuver-object)
 
 ### Waypoint
 
@@ -365,5 +365,5 @@ Object used to describe waypoint on a route.
 
 **Parameters**
 
--   `exteral` **documentation** in
-    [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#waypoint)
+-   **documentation** in
+    [`osrm-backend`](../http.md#waypoint-object)

features/testbot/distance_matrix.feature

@@ -5,21 +5,49 @@ Feature: Basic Distance Matrix
     Background:
         Given the profile "testbot"
         And the partition extra arguments "--small-component-size 1 --max-cell-sizes 2,4,8,16"
-
-    Scenario: Testbot - Travel distance matrix of minimal network
+  Scenario: Testbot - Travel distance matrix of small grid
         Given the node map
             """
-            a b
+            a b c
+            d e f
             """
 
         And the ways
             | nodes |
-            | ab    |
+            | abc   |
+            | def   |
+            | ad    |
+            | be    |
+            | cf    |
 
         When I request a travel distance matrix I should get
-            |   | a      | b      |
-            | a | 0      | 100+-1 |
-            | b | 100+-1 | 0      |
+            |   |    a    |    b    |     e   |   f    |
+            | a |    0    |  100.1  |  199.5  |  299.5 |
+            | b |  100.1  |   0     |  99.4   |  199.5 |
+            | e |  199.5  |  99.4   |   0     |  100.1 |
+            | f |  299.5  |  199.5  |  100.1  |   0    |
+
+    Scenario: Testbot - Travel distance matrix of minimal network exact distances
+        Given the node map
+            """
+            a z
+              b
+              c
+              d
+            """
+
+        And the ways
+            | nodes |
+            | az    |
+            | zbcd  |
+
+        When I request a travel distance matrix I should get
+            |   |   a    |   z     |   b     |   c     |   d     |
+            | a |   0    |  100.1  |  199.5  |  298.9  |  398.3  |
+            | z |  100.1 |  0      |  99.4   |  198.8  |  298.2  |
+            | b |  199.5 |  99.4   |  0      |  99.4   |  198.8  |
+            | c |  298.9 |  198.8  |  99.4   |  0      |  99.4   |
+            | d |  398.3 |  298.2  |  198.8  |  99.4   |  0      |
 
     Scenario: Testbot - Travel distance matrix of minimal network with toll exclude
         Given the query options
@@ -39,11 +67,11 @@ Feature: Basic Distance Matrix
             | bd    | motorway | yes  | not drivable for exclude=toll and exclude=motorway,toll |
 
         When I request a travel distance matrix I should get
-            |   | a      | b      | c      | d      |
-            | a | 0      | 100+-1 |        |        |
-            | b | 100+-1 | 0      |        |        |
-            | c |        |        | 0      | 100+-1 |
-            | d |        |        | 100+-1 | 0      |
+            |   | a     | b     | c     | d     |
+            | a | 0     | 100.1 |       |       |
+            | b | 100.1 | 0     |       |       |
+            | c |       |       | 0     | 100.1 |
+            | d |       |       | 100.1 | 0     |
 
     Scenario: Testbot - Travel distance matrix of minimal network with motorway exclude
         Given the query options
@@ -63,8 +91,8 @@ Feature: Basic Distance Matrix
             | bd    | residential |                                   |
 
         When I request a travel distance matrix I should get
-            |   | a | b      | c      | d      |
-            | a | 0 | 300+-2 | 100+-2 | 200+-2 |
+            |   | a |   b    |  c   |   d   |
+            | a | 0 |  298.9 | 99.4 | 199.5 |
 
     Scenario: Testbot - Travel distance matrix of minimal network disconnected motorway exclude
         Given the query options
@@ -84,8 +112,8 @@ Feature: Basic Distance Matrix
             | efgh  | residential |                                   |
 
         When I request a travel distance matrix I should get
-            |   | a | b     | e |
-            | a | 0 | 50+-1 |   |
+            |   | a | b    | e |
+            | a | 0 | 50.1 |   |
 
     Scenario: Testbot - Travel distance matrix of minimal network with motorway and toll excludes
         Given the query options
@@ -106,7 +134,7 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a | b      | e | g |
-            | a | 0 | 100+-1 |   |   |
+            | a | 0 | 100.1  |   |   |
 
     Scenario: Testbot - Travel distance matrix with different way speeds
         Given the node map
@@ -121,22 +149,22 @@ Feature: Basic Distance Matrix
             | cd    | tertiary  |
 
         When I request a travel distance matrix I should get
-            |   | a      | b      | c      | d      |
-            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
-            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
-            | c | 200+-1 | 100+-1 | 0      | 100+-1 |
-            | d | 300+-1 | 200+-1 | 100+-1 | 0     |
+            |   | a     | b     | c     | d     |
+            | a | 0     | 100.1 | 200.1 | 300.2 |
+            | b | 100.1 | 0     | 100.1 | 200.1 |
+            | c | 200.1 | 100.1 | 0     | 100.1 |
+            | d | 300.2 | 200.1 | 100.1 | 0     |
 
         When I request a travel distance matrix I should get
-            |   | a | b      | c      | d      |
-            | a | 0 | 100+-1 | 200+-1 | 300+-1 |
+            |   | a | b     | c     | d     |
+            | a | 0 | 100.1 | 200.1 | 300.2 |
 
         When I request a travel distance matrix I should get
-            |   | a      |
-            | a | 0      |
-            | b | 100+-1 |
-            | c | 200+-1 |
-            | d | 300+-1 |
+            |   | a     |
+            | a | 0     |
+            | b | 100.1 |
+            | c | 200.1 |
+            | d | 300.2 |
 
     Scenario: Testbot - Travel distance matrix of small grid
         Given the node map
@@ -154,11 +182,11 @@ Feature: Basic Distance Matrix
             | cf    |
 
         When I request a travel distance matrix I should get
-            |   | a      | b      | e      | f      |
-            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
-            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
-            | e | 200+-1 | 100+-1 | 0      | 100+-1 |
-            | f | 300+-1 | 200+-1 | 100+-1 | 0      |
+            |   | a     | b     | e     | f     |
+            | a | 0     | 100.1 | 199.5 | 299.5 |
+            | b | 100.1 | 0     | 99.4  | 199.5 |
+            | e | 199.5 | 99.4  | 0     | 100.1 |
+            | f | 299.5 | 199.5 | 100.1 | 0     |
 
     Scenario: Testbot - Travel distance matrix of network with unroutable parts
         Given the node map
@@ -172,7 +200,7 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a | b      |
-            | a | 0 | 100+-1 |
+            | a | 0 | 100.1  |
             | b |   | 0      |
 
     Scenario: Testbot - Travel distance matrix of network with oneways
@@ -189,11 +217,11 @@ Feature: Basic Distance Matrix
             | by    |        |
 
         When I request a travel distance matrix I should get
-            |   | x      | y      | d      | e      |
-            | x | 0      | 300+-2 | 400+-2 | 300+-2 |
-            | y | 500+-2 | 0      | 300+-2 | 200+-2 |
-            | d | 200+-2 | 300+-2 | 0      | 300+-2 |
-            | e | 300+-2 | 400+-2 | 100+-2 | 0      |
+            |   | x     | y     | d     | e     |
+            | x | 0     | 300.2 | 399.6 | 299.5 |
+            | y | 499   | 0     | 299.5 | 199.5 |
+            | d | 199.5 | 299.5 | 0     | 298.9 |
+            | e | 299.5 | 399.6 | 100.1 | 0     |
 
     Scenario: Testbot - Rectangular travel distance matrix
         Given the node map
@@ -212,53 +240,53 @@ Feature: Basic Distance Matrix
 
         When I route I should get
             | from | to | distance  |
-            | e    | a  | 200m +- 1 |
-            | e    | b  | 100m +- 1 |
-            | f    | a  | 300m +- 1 |
-            | f    | b  | 200m +- 1 |
+            | e    | a  | 200m      |
+            | e    | b  | 100m      |
+            | f    | a  | 299.9m    |
+            | f    | b  | 200m      |
 
         When I request a travel distance matrix I should get
             |   | a | b      | e      | f      |
-            | a | 0 | 100+-1 | 200+-1 | 300+-1 |
+            | a | 0 |  100.1 |  199.5 |  299.5 |
 
         When I request a travel distance matrix I should get
-            |   | a      |
-            | a | 0      |
-            | b | 100+-1 |
-            | e | 200+-1 |
-            | f | 300+-1 |
+            |   | a     |
+            | a | 0     |
+            | b | 100.1 |
+            | e | 199.5 |
+            | f | 299.5 |
 
         When I request a travel distance matrix I should get
-            |   | a      | b      | e      | f      |
-            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
-            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
+            |   | a     | b     | e     | f     |
+            | a | 0     | 100.1 | 199.5 | 299.5 |
+            | b | 100.1 | 0     | 99.4  | 199.5 |
 
         When I request a travel distance matrix I should get
-            |   | a      | b      |
-            | a | 0      | 100+-1 |
-            | b | 100+-1 | 0      |
-            | e | 200+-1 | 100+-1 |
-            | f | 300+-1 | 200+-1 |
+            |   | a     | b     |
+            | a | 0     | 100.1 |
+            | b | 100.1 | 0     |
+            | e | 199.5 | 99.4  |
+            | f | 299.5 | 199.5 |
 
         When I request a travel distance matrix I should get
-            |   | a      | b      | e      | f      |
-            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
-            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
-            | e | 200+-1 | 100+-1 | 0      | 100+-1 |
+            |   | a     | b     | e     | f     |
+            | a | 0     | 100.1 | 199.5 | 299.5 |
+            | b | 100.1 | 0     | 99.4  | 199.5 |
+            | e | 199.5 | 99.4  | 0     | 100.1 |
 
         When I request a travel distance matrix I should get
-            |   | a      | b      | e      |
-            | a | 0      | 100+-1 | 200+-1 |
-            | b | 100+-1 | 0      | 100+-1 |
-            | e | 200+-1 | 100+-1 | 0      |
-            | f | 300+-1 | 200+-1 | 100+-1 |
+             |   | a     | b     | e     |
+             | a | 0     | 100.1 | 199.5 |
+             | b | 100.1 | 0     | 99.4  |
+             | e | 199.5 | 99.4  | 0     |
+             | f | 299.5 | 199.5 | 100.1 |
 
         When I request a travel distance matrix I should get
-            |   | a      | b      | e      | f      |
-            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
-            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
-            | e | 200+-1 | 100+-1 | 0      | 100+-1 |
-            | f | 300+-1 | 200+-1 | 100+-1 | 0      |
+             |   | a     | b     | e     | f     |
+             | a | 0     | 100.1 | 199.5 | 299.5 |
+             | b | 100.1 | 0     | 99.4  | 199.5 |
+             | e | 199.5 | 99.4  | 0     | 100.1 |
+             | f | 299.5 | 199.5 | 100.1 | 0     |
 
      Scenario: Testbot - Travel distance 3x2 matrix
         Given the node map
@@ -277,9 +305,9 @@ Feature: Basic Distance Matrix
 
 
         When I request a travel distance matrix I should get
-            |   | b      | e      | f      |
-            | a | 100+-1 | 200+-1 | 300+-1 |
-            | b | 0      | 100+-1 | 200+-1 |
+            |   | b     | e     | f     |
+            | a | 100.1 | 199.5 | 299.5 |
+            | b | 0     | 99.4  | 199.5 |
 
     Scenario: Testbot - All coordinates are from same small component
         Given a grid size of 300 meters
@@ -299,9 +327,9 @@ Feature: Basic Distance Matrix
             | fg    |
 
         When I request a travel distance matrix I should get
-            |   | f      | g      |
-            | f | 0      | 300+-2 |
-            | g | 300+-2 | 0      |
+            |   | f     | g     |
+            | f | 0     | 298.2 |
+            | g | 298.2 | 0     |
 
     Scenario: Testbot - Coordinates are from different small component and snap to big CC
         Given a grid size of 300 meters
@@ -333,11 +361,11 @@ Feature: Basic Distance Matrix
             | i    | h  | 300m     |
 
         When I request a travel distance matrix I should get
-            |   | f      | g      | h      | i      |
-            | f | 0      | 300+-2 | 0      | 300+-2 |
-            | g | 300+-2 | 0      | 300+-2 | 0      |
-            | h | 0      | 300+-2 | 0      | 300+-2 |
-            | i | 300+-2 | 0      | 300+-2 | 0      |
+            |   | f     | g     | h     | i     |
+            | f | 0     | 298.2 | 0     | 298.2 |
+            | g | 298.2 | 0     | 298.2 | 0     |
+            | h | 0     | 298.2 | 0     | 298.2 |
+            | i | 298.2 | 0     | 298.2 | 0     |
 
     Scenario: Testbot - Travel distance matrix with loops
         Given the node map
@@ -354,11 +382,11 @@ Feature: Basic Distance Matrix
             | da    | yes |
 
         When I request a travel distance matrix I should get
-            |   | 1      | 2      | 3      | 4      |
-            | 1 | 0      | 100+-1 | 400+-1 | 500+-1 |
-            | 2 | 700+-1 | 0      | 300+-1 | 400+-1 |
-            | 3 | 400+-1 | 500+-1 | 0      | 100+-1 |
-            | 4 | 300+-1 | 400+-1 | 700+-1 | 0      |
+            |   | 1     | 2     | 3     | 4     |
+            | 1 | 0     | 100.1 | 399.6 | 499.7 |
+            | 2 | 699.1 | 0     | 299.5 | 399.6 |
+            | 3 | 399.6 | 499.7 | 0     | 100.1 |
+            | 4 | 299.5 | 399.6 | 699.1 | 0     |
 
 
     Scenario: Testbot - Travel distance matrix based on segment durations
@@ -395,12 +423,12 @@ Feature: Basic Distance Matrix
             | ce    |
 
         When I request a travel distance matrix I should get
-            |   | a      | b      | c      | d      | e      |
-            | a | 0      | 100+-2 | 200+-2 | 300+-2 | 400+-2 |
-            | b | 100+-2 | 0      | 100+-2 | 200+-2 | 300+-2 |
-            | c | 200+-2 | 100+-2 | 0      | 100+-2 | 200+-2 |
-            | d | 300+-2 | 200+-2 | 100+-2 | 0      | 300+-2 |
-            | e | 400+-2 | 300+-2 | 200+-2 | 300+-2 | 0      |
+            |   | a     | b     | c     | d     | e     |
+            | a | 0     | 100.1 | 200.1 | 300.2 | 398.9 |
+            | b | 100.1 | 0     | 100.1 | 200.1 | 298.9 |
+            | c | 200.1 | 100.1 | 0     | 100.1 | 198.8 |
+            | d | 300.2 | 200.1 | 100.1 | 0     | 298.9 |
+            | e | 398.9 | 298.9 | 198.8 | 298.9 | 0     |
 
     Scenario: Testbot - Travel distance matrix for alternative loop paths
         Given the profile file
@@ -439,26 +467,26 @@ Feature: Basic Distance Matrix
             | ca    | yes    |
 
         When I request a travel distance matrix I should get
-            |   | 1       | 2       | 3       | 4       | 5       | 6       | 7       | 8       |
-            | 1 | 0       | 1100+-5 | 300+-5  | 200+-5  | 600+-5  | 500+-5  | 900+-5  | 800+-5  |
-            | 2 | 100+-5  | 0       | 400+-5  | 300+-5  | 700+-5  | 600+-5  | 1000+-5 | 900+-5  |
-            | 3 | 900+-5  | 800+-5  | 0       | 1100+-5 | 300+-5  | 200+-5  | 600+-5  | 500+-5  |
-            | 4 | 1000+-5 | 900+-5  | 100+-5  | 0       | 400+-5  | 300+-5  | 700+-5  | 600+-5  |
-            | 5 | 600+-5  | 500+-5  | 900+-5  | 800+-5  | 0       | 1100+-5 | 300+-5  | 200+-5  |
-            | 6 | 700+-5  | 600+-5  | 1000+-5 | 900+-5  | 100+-5  | 0       | 400+-5  | 300+-5  |
-            | 7 | 300+-5  | 200+-5  | 600+-5  | 500+-5  | 900+-5  | 800+-5  | 0       | 1100+-5 |
-            | 8 | 400+-5  | 300+-5  | 700+-5  | 600+-5  | 1000+-5 | 900+-5  | 100+-5  | 0       |
+             |   | 1     | 2      | 3     | 4      | 5     | 6      | 7     | 8      |
+             | 1 | 0     | 1096.7 | 298.9 | 199.5  | 598.4 | 498.3  | 897.3 | 797.9  |
+             | 2 | 100.1 | 0      | 398.9 | 299.5  | 698.5 | 598.4  | 997.3 | 897.9  |
+             | 3 | 897.9 | 797.9  | 0     | 1097.4 | 299.5 | 199.5  | 598.4 | 499    |
+             | 4 | 997.3 | 897.3  | 99.4  | 0      | 398.9 | 298.9  | 697.8 | 598.4  |
+             | 5 | 598.4 | 498.3  | 897.3 | 797.9  | 0     | 1096.7 | 298.9 | 199.5  |
+             | 6 | 698.5 | 598.4  | 997.3 | 897.9  | 100.1 | 0      | 398.9 | 299.5  |
+             | 7 | 299.5 | 199.5  | 598.4 | 499    | 897.9 | 797.9  | 0     | 1097.4 |
+             | 8 | 398.9 | 298.9  | 697.8 | 598.4  | 997.3 | 897.3  | 99.4  | 0      |
 
         When I request a travel distance matrix I should get
-            |   | 1       |
-            | 1 | 0       |
-            | 2 | 100+-5  |
-            | 3 | 900+-5  |
-            | 4 | 1000+-5 |
-            | 5 | 600+-5  |
-            | 6 | 700+-5  |
-            | 7 | 300+-5  |
-            | 8 | 400+-5  |
+             |   | 1     |
+             | 1 | 0     |
+             | 2 | 100.1 |
+             | 3 | 897.9 |
+             | 4 | 997.3 |
+             | 5 | 598.4 |
+             | 6 | 698.5 |
+             | 7 | 299.5 |
+             | 8 | 398.9 |
 
     Scenario: Testbot - Travel distance matrix with ties
         Given the node map
@@ -480,26 +508,26 @@ Feature: Basic Distance Matrix
             | a    | c  | ac,ac | 200m     | 20s  |     20 |
 
         When I route I should get
-            | from | to | route    | distance  |
-            | a    | b  | ab,ab    | 450m      |
-            | a    | c  | ac,ac    | 200m      |
-            | a    | d  | ac,dc,dc | 500m +- 1 |
+            | from | to | route    | distance |
+            | a    | b  | ab,ab    | 450m     |
+            | a    | c  | ac,ac    | 200m     |
+            | a    | d  | ac,dc,dc | 499.9m   |
 
         When I request a travel distance matrix I should get
-            |   | a | b      | c      | d      |
-            | a | 0 | 450+-2 | 200+-2 | 500+-2 |
+            |   | a | b     | c     | d   |
+            | a | 0 | 450.3 | 198.8 | 499 |
 
         When I request a travel distance matrix I should get
-            |   | a      |
-            | a | 0      |
-            | b | 450+-2 |
-            | c | 200+-2 |
-            | d | 500+-2 |
+            |   | a     |
+            | a | 0     |
+            | b | 450.3 |
+            | c | 198.8 |
+            | d | 499   |
 
         When I request a travel distance matrix I should get
-            |   | a      | c      |
-            | a | 0      | 200+-2 |
-            | c | 200+-2 | 0      |
+            |   | a     | c     |
+            | a | 0     | 198.8 |
+            | c | 198.8 | 0     |
 
 
     # Check rounding errors
@@ -515,8 +543,8 @@ Feature: Basic Distance Matrix
             | abcd     |
 
         When I request a travel distance matrix I should get
-            |   | a | b       | c       | d       |
-            | a | 0 | 1000+-3 | 2000+-3 | 3000+-3 |
+            |   | a | b      | c      | d      |
+            | a | 0 | 1000.7 | 2001.4 | 3002.1 |
 
 
     Scenario: Testbot - OneToMany vs ManyToOne
@@ -560,10 +588,34 @@ Feature: Basic Distance Matrix
             | fd     |        |
 
         When I request a travel distance matrix I should get
-            |   | a       | b       | c       | d       | e       | f       |
-            | a | 0       | 100+-1  | 300+-1  | 650+-1  | 1930+-1 | 1533+-1 |
-            | b | 760+-1  | 0       | 200+-1  | 550+-1  | 1830+-1 | 1433+-1 |
-            | c | 560+-2  | 660+-2  | 0       | 350+-1  | 1630+-1 | 1233+-1 |
-            | d | 1480+-2 | 1580+-1 | 1780+-1 | 0       | 1280+-1 | 883+-1  |
-            | e | 200+-2  | 300+-2  | 500+-1  | 710+-1  | 0       | 1593+-1 |
-            | f | 597+-1  | 696+-1  | 896+-1  | 1108+-1 | 400+-3  | 0       |
+            |   | a      | b     | c      | d      | e      | f      |
+            | a | 0      | 100.1 | 300.2  | 650.5  | 1930.6 | 1533   |
+            | b | 759    | 0     | 200.1  | 550.4  | 1830.5 | 1432.9 |
+            | c | 558.8  | 658.9 | 0      | 350.3  | 1630.4 | 1232.8 |
+            | d | 1478.9 | 1579  | 1779.1 | 0      | 1280.1 | 882.5  |
+            | e | 198.8  | 298.9 | 499    | 710.3  | 0      | 1592.8 |
+            | f | 596.4  | 696.5 | 896.6  | 1107.9 | 397.6  | 0      |
+
+
+    Scenario: Testbot - Filling in noroutes with estimates
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the query options
+            | noroute_estimate | 5 |
+        Given the node map
+            """
+            a b   f h
+            d e   g i
+            """
+
+        And the ways
+            | nodes |
+            | abeda |
+            | fhigf |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b     | f     | h      |
+            | a | 0      | 300.2 | 900.7 | 1200.9 |
+            | b | 300.2  | 0     | 600.5 | 900.7  |
+            | f | 900.7  | 600.5 | 0     | 302.2  |
+            | h | 1200.9 | 900.7 | 300.2 | 0      |

features/testbot/duration_matrix.feature

@@ -510,3 +510,26 @@ Feature: Basic Duration Matrix
             |   |   a   |
             | a |   0   |
             | b | 24.1  |
+
+    Scenario: Testbot - Filling in noroutes with estimates
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the query options
+            | noroute_estimate | 5 |
+        Given the node map
+            """
+            a b   f h
+            d e   g i
+            """
+
+        And the ways
+            | nodes |
+            | abeda |
+            | fhigf |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | f  | h  |
+            | a | 0  | 30 | 18 | 24 |
+            | b | 30 | 0  | 12 | 18 |
+            | f | 18 | 12 | 0  | 30 |
+            | h | 24 | 18 | 30 | 0  |

features/testbot/multi_level_routing.feature

@@ -38,15 +38,15 @@ Feature: Multi level routing
     Scenario: Testbot - Multi level routing
         Given the node map
             """
-            a───b   e───f
-            │   │   │   │
+           a────b   e─────f
+            \   │   │    /
             d───c   h───g
                  ╲ ╱
                   ╳
                  ╱ ╲
             i───j   m───n
-            │   │   │   │
-            l───k───p───o
+           /    │   │    \
+          l─────k───p─────o
             """
 
         And the nodes
@@ -67,78 +67,76 @@ Feature: Multi level routing
 
         When I route I should get
             | from | to | route                                  | time   |
-            | a    | b  | abcda,abcda                            | 20s    |
-            | a    | f  | abcda,cm,mnopm,kp,ijkli,hj,efghe,efghe | 229.4s |
-            | a    | l  | abcda,cm,mnopm,kp,ijkli,ijkli          | 144.7s |
-            | a    | o  | abcda,cm,mnopm,mnopm,mnopm             | 124.7s |
-            | f    | l  | efghe,hj,ijkli,ijkli,ijkli             | 124.7s |
-            | f    | o  | efghe,hj,ijkli,kp,mnopm,mnopm          | 144.7s |
-            | l    | o  | ijkli,kp,mnopm,mnopm                   | 60s    |
+            | a    | b  | abcda,abcda                            | 25s    |
+            | a    | f  | abcda,cm,mnopm,kp,ijkli,hj,efghe,efghe | 239.2s |
+            | a    | l  | abcda,cm,mnopm,kp,ijkli,ijkli          | 157.1s |
+            | a    | o  | abcda,cm,mnopm,mnopm,mnopm             | 137.1s |
+            | f    | l  | efghe,hj,ijkli,ijkli                   | 136.7s |
+            | f    | o  | efghe,hj,ijkli,kp,mnopm,mnopm          | 162.1s |
+            | l    | o  | ijkli,kp,mnopm,mnopm                   | 80s    |
             | c    | m  | cm,cm                                  | 44.7s  |
+            | f    | a  | efghe,hj,ijkli,kp,mnopm,cm,abcda,abcda | 239.2s |
+            | l    | a  | ijkli,kp,mnopm,cm,abcda,abcda          | 157.1s |
 
         When I request a travel time matrix I should get
-            |   |     a |     f |     l |     o |
-            | a |     0 | 229.4 | 144.7 | 124.7 |
-            | f | 229.4 |     0 | 124.7 | 144.7 |
-            | l | 144.7 | 124.7 |     0 |    60 |
-            | o | 124.7 | 144.7 |    60 |     0 |
+            |   | a     | f     | l     | o     |
+            | a | 0     | 239.2 | 157.1 | 137.1 |
+            | f | 239.2 | 0     | 136.7 | 162.1 |
+            | l | 157.1 | 136.7 | 0     | 80    |
+            | o | 137.1 | 162.1 | 80    | 0     |
 
         When I request a travel time matrix I should get
-            |   |     a |     f |     l |     o |
-            | a |     0 | 229.4 | 144.7 | 124.7 |
+            |   | a | f     | l     | o     |
+            | a | 0 | 239.2 | 157.1 | 137.1 |
 
         When I request a travel time matrix I should get
-            |   |     a |
-            | a |     0 |
-            | f | 229.4 |
-            | l | 144.7 |
-            | o | 124.7 |
+            |   |   a   |
+            | a |   0   |
+            | f | 239.2 |
+            | l | 157.1 |
+            | o | 137.1 |
 
         When I request a travel time matrix I should get
-            |   |     a |     f |     l |     o |
-            | a |     0 | 229.4 | 144.7 | 124.7 |
-            | o | 124.7 | 144.7 |    60 |     0 |
+            |   | a     | f     | l     | o     |
+            | a | 0     | 239.2 | 157.1 | 137.1 |
+            | o | 137.1 | 162.1 | 80    | 0     |
 
         When I request a travel time matrix I should get
             |   |     a |     o |
-            | a |     0 | 124.7 |
-            | f | 229.4 | 144.7 |
-            | l | 144.7 |    60 |
-            | o | 124.7 |     0 |
-
+            | a |     0 | 137.1 |
+            | f | 239.2 | 162.1 |
+            | l | 157.1 |    80 |
+            | o | 137.1 |     0 |
 
         When I request a travel distance matrix I should get
-            |   |       a |       f |       l |         o |
-            | a |    0+-2 | 2287+-2 | 1443+-2 |   1243+-2 |
-            | f | 2284+-2 |    0+-2 | 1241+-2 |   1443+-2 |
-            | l | 1443+-2 | 1244+-2 |    0+-2 |    600+-2 |
-            | o | 1243+-2 | 1444+-2 |  600+-2 |      0+-2 |
+            |   | a      | f      | l      | o      |
+            | a | 0      | 2383.7 | 1566.9 | 1366.8 |
+            | f | 2339.9 | 0      | 1198.1 | 1522.1 |
+            | l | 1618.3 | 1293.3 | 0      | 800.5  |
+            | o | 1418.2 | 1617.3 | 800.5  | 0      |
 
         When I request a travel distance matrix I should get
-            |   | a | f          | l          | o        |
-            | a | 0 | 2287.2+-2  | 1443+-2    | 1243+-2  |
+            |   | a | f      | l      | o      |
+            | a | 0 | 2383.7 | 1566.9 | 1366.8 |
 
         When I request a travel distance matrix I should get
-            |   |         a |
-            | a |         0 |
-            | f | 2284.5+-2 |
-            | l |    1443.1 |
-            | o |      1243 |
+            |   | a      |
+            | a | 0      |
+            | f | 2339.9 |
+            | l | 1618.3 |
+            | o | 1418.2 |
 
         When I request a travel distance matrix I should get
-            |   |    a |      f  |      l  |       o |
-            | a |    0 | 2287+-2 | 1443+-2 | 1243+-2 |
-            | o | 1243 | 1444+-2 |  600+-2 |    0+-2 |
-
+            |   | a      | f      | l      | o      |
+            | a | 0      | 2383.7 | 1566.9 | 1366.8 |
+            | f | 2339.9 | 0      | 1198.1 | 1522.1 |
 
         When I request a travel distance matrix I should get
-            |   |         a |        o  |
-            | a |      0+-2 |   1243+-2 |
-            | f |   2284+-2 |   1443+-2 |
-            | l |   1443+-2 |    600+-2 |
-            | o |   1243+-2 |      0+-2 |
-
-
+            |   | a      | o      |
+            | a | 0      | 1366.8 |
+            | f | 2339.9 | 1522.1 |
+            | l | 1618.3 | 800.5  |
+            | o | 1418.2 | 0      |
 
     Scenario: Testbot - Multi level routing: horizontal road
         Given the node map

include/contractor/contractor_config.hpp

@@ -72,14 +72,8 @@ struct ContractorConfig final : storage::IOConfig
     // The remaining vertices form the core of the hierarchy
     //(e.g. 0.8 contracts 80 percent of the hierarchy, leaving a core of 20%)
     double core_factor;
-
-    // Whether to store distances for CH edges in addition to duration/weight
-    // Defaults to false.  Setting to true will require more storage/memory,
-    // but avoids the need for path unpacking to learn the distance of a CH
-    // route (useful for faster distance results in table queries)
-    bool cache_distances;
 };
-} // namespace contractor
-} // namespace osrm
+}
+}
 
 #endif // EXTRACTOR_OPTIONS_HPP

include/contractor/query_edge.hpp

@@ -77,7 +77,7 @@ struct QueryEdge
                 data.distance == right.data.distance);
     }
 };
-} // namespace contractor
-} // namespace osrm
+}
+}
 
 #endif // QUERYEDGE_HPP

include/customizer/cell_customizer.hpp

@@ -22,6 +22,7 @@ class CellCustomizer
     {
         bool from_clique;
         EdgeDuration duration;
+        EdgeDistance distance;
     };
 
   public:
@@ -60,7 +61,7 @@ class CellCustomizer
                 }
             }
             heap.Clear();
-            heap.Insert(source, 0, {false, 0});
+            heap.Insert(source, 0, {false, 0, 0});
 
             // explore search space
             while (!heap.Empty() && !destinations_set.empty())
@@ -68,8 +69,18 @@ class CellCustomizer
                 const NodeID node = heap.DeleteMin();
                 const EdgeWeight weight = heap.GetKey(node);
                 const EdgeDuration duration = heap.GetData(node).duration;
+                const EdgeDistance distance = heap.GetData(node).distance;
 
-                RelaxNode(graph, cells, allowed_nodes, metric, heap, level, node, weight, duration);
+                RelaxNode(graph,
+                          cells,
+                          allowed_nodes,
+                          metric,
+                          heap,
+                          level,
+                          node,
+                          weight,
+                          duration,
+                          distance);
 
                 destinations_set.erase(node);
             }
@@ -77,21 +88,27 @@ class CellCustomizer
             // fill a map of destination nodes to placeholder pointers
             auto weights = cell.GetOutWeight(source);
             auto durations = cell.GetOutDuration(source);
+            auto distances = cell.GetOutDistance(source);
             for (auto &destination : destinations)
             {
                 BOOST_ASSERT(!weights.empty());
                 BOOST_ASSERT(!durations.empty());
+                BOOST_ASSERT(!distances.empty());
 
                 const bool inserted = heap.WasInserted(destination);
                 weights.front() = inserted ? heap.GetKey(destination) : INVALID_EDGE_WEIGHT;
                 durations.front() =
                     inserted ? heap.GetData(destination).duration : MAXIMAL_EDGE_DURATION;
+                distances.front() =
+                    inserted ? heap.GetData(destination).distance : INVALID_EDGE_DISTANCE;
 
                 weights.advance_begin(1);
                 durations.advance_begin(1);
+                distances.advance_begin(1);
             }
             BOOST_ASSERT(weights.empty());
             BOOST_ASSERT(durations.empty());
+            BOOST_ASSERT(distances.empty());
         }
     }
 
@@ -128,7 +145,8 @@ class CellCustomizer
                    LevelID level,
                    NodeID node,
                    EdgeWeight weight,
-                   EdgeDuration duration) const
+                   EdgeDuration duration,
+                   EdgeDistance distance) const
     {
         auto first_level = level == 1;
         BOOST_ASSERT(heap.WasInserted(node));
@@ -149,6 +167,7 @@ class CellCustomizer
                 auto subcell = cells.GetCell(metric, level - 1, subcell_id);
                 auto subcell_destination = subcell.GetDestinationNodes().begin();
                 auto subcell_duration = subcell.GetOutDuration(node).begin();
+                auto subcell_distance = subcell.GetOutDistance(node).begin();
                 for (auto subcell_weight : subcell.GetOutWeight(node))
                 {
                     if (subcell_weight != INVALID_EDGE_WEIGHT)
@@ -161,20 +180,24 @@ class CellCustomizer
 
                         const EdgeWeight to_weight = weight + subcell_weight;
                         const EdgeDuration to_duration = duration + *subcell_duration;
+                        const EdgeDistance to_distance = distance + *subcell_distance;
                         if (!heap.WasInserted(to))
                         {
-                            heap.Insert(to, to_weight, {true, to_duration});
+                            heap.Insert(to, to_weight, {true, to_duration, to_distance});
                         }
-                        else if (std::tie(to_weight, to_duration) <
-                                 std::tie(heap.GetKey(to), heap.GetData(to).duration))
+                        else if (std::tie(to_weight, to_duration, to_distance) <
+                                 std::tie(heap.GetKey(to),
+                                          heap.GetData(to).duration,
+                                          heap.GetData(to).distance))
                         {
                             heap.DecreaseKey(to, to_weight);
-                            heap.GetData(to) = {true, to_duration};
+                            heap.GetData(to) = {true, to_duration, to_distance};
                         }
                     }
 
                     ++subcell_destination;
                     ++subcell_duration;
+                    ++subcell_distance;
                 }
             }
         }
@@ -195,15 +218,18 @@ class CellCustomizer
             {
                 const EdgeWeight to_weight = weight + data.weight;
                 const EdgeDuration to_duration = duration + data.duration;
+                const EdgeDistance to_distance = distance + data.distance;
                 if (!heap.WasInserted(to))
                 {
-                    heap.Insert(to, to_weight, {false, duration + data.duration});
+                    heap.Insert(
+                        to, to_weight, {false, duration + data.duration, distance + data.distance});
                 }
-                else if (std::tie(to_weight, to_duration) <
-                         std::tie(heap.GetKey(to), heap.GetData(to).duration))
+                else if (std::tie(to_weight, to_duration, to_distance) <
+                         std::tie(
+                             heap.GetKey(to), heap.GetData(to).duration, heap.GetData(to).distance))
                 {
                     heap.DecreaseKey(to, to_weight);
-                    heap.GetData(to) = {false, to_duration};
+                    heap.GetData(to) = {false, to_duration, to_distance};
                 }
             }
         }

include/customizer/cell_metric.hpp

@@ -20,6 +20,7 @@ template <storage::Ownership Ownership> struct CellMetricImpl
 
     Vector<EdgeWeight> weights;
     Vector<EdgeDuration> durations;
+    Vector<EdgeDistance> distances;
 };
 }
 

include/customizer/edge_based_graph.hpp

@@ -58,8 +58,10 @@ class MultiLevelGraph : public partitioner::MultiLevelGraph<EdgeDataT, Ownership
 
     MultiLevelGraph(PartitionerGraphT &&graph,
                     Vector<EdgeWeight> node_weights_,
-                    Vector<EdgeDuration> node_durations_)
-        : node_weights(std::move(node_weights_)), node_durations(std::move(node_durations_))
+                    Vector<EdgeDuration> node_durations_,
+                    Vector<EdgeDistance> node_distances_)
+        : node_weights(std::move(node_weights_)), node_durations(std::move(node_durations_)),
+          node_distances(std::move(node_distances_))
     {
         util::ViewOrVector<PartitionerGraphT::EdgeArrayEntry, storage::Ownership::Container>
             original_edge_array;
@@ -83,11 +85,13 @@ class MultiLevelGraph : public partitioner::MultiLevelGraph<EdgeDataT, Ownership
                     Vector<EdgeOffset> node_to_edge_offset_,
                     Vector<EdgeWeight> node_weights_,
                     Vector<EdgeDuration> node_durations_,
+                    Vector<EdgeDistance> node_distances_,
                     Vector<bool> is_forward_edge_,
                     Vector<bool> is_backward_edge_)
         : SuperT(std::move(node_array_), std::move(edge_array_), std::move(node_to_edge_offset_)),
           node_weights(std::move(node_weights_)), node_durations(std::move(node_durations_)),
-          is_forward_edge(is_forward_edge_), is_backward_edge(is_backward_edge_)
+          node_distances(std::move(node_distances_)), is_forward_edge(is_forward_edge_),
+          is_backward_edge(is_backward_edge_)
     {
     }
 
@@ -95,6 +99,8 @@ class MultiLevelGraph : public partitioner::MultiLevelGraph<EdgeDataT, Ownership
 
     EdgeWeight GetNodeDuration(NodeID node) const { return node_durations[node]; }
 
+    EdgeDistance GetNodeDistance(NodeID node) const { return node_distances[node]; }
+
     bool IsForwardEdge(EdgeID edge) const { return is_forward_edge[edge]; }
 
     bool IsBackwardEdge(EdgeID edge) const { return is_backward_edge[edge]; }
@@ -111,6 +117,7 @@ class MultiLevelGraph : public partitioner::MultiLevelGraph<EdgeDataT, Ownership
   protected:
     Vector<EdgeWeight> node_weights;
     Vector<EdgeDuration> node_durations;
+    Vector<EdgeDistance> node_distances;
     Vector<bool> is_forward_edge;
     Vector<bool> is_backward_edge;
 };

include/customizer/serialization.hpp

@@ -23,6 +23,7 @@ inline void read(storage::tar::FileReader &reader,
 {
     storage::serialization::read(reader, name + "/weights", metric.weights);
     storage::serialization::read(reader, name + "/durations", metric.durations);
+    storage::serialization::read(reader, name + "/distances", metric.distances);
 }
 
 template <storage::Ownership Ownership>
@@ -32,6 +33,7 @@ inline void write(storage::tar::FileWriter &writer,
 {
     storage::serialization::write(writer, name + "/weights", metric.weights);
     storage::serialization::write(writer, name + "/durations", metric.durations);
+    storage::serialization::write(writer, name + "/distances", metric.distances);
 }
 
 template <typename EdgeDataT, storage::Ownership Ownership>
@@ -42,6 +44,7 @@ inline void read(storage::tar::FileReader &reader,
     storage::serialization::read(reader, name + "/node_array", graph.node_array);
     storage::serialization::read(reader, name + "/node_weights", graph.node_weights);
     storage::serialization::read(reader, name + "/node_durations", graph.node_durations);
+    storage::serialization::read(reader, name + "/node_distances", graph.node_distances);
     storage::serialization::read(reader, name + "/edge_array", graph.edge_array);
     storage::serialization::read(reader, name + "/is_forward_edge", graph.is_forward_edge);
     storage::serialization::read(reader, name + "/is_backward_edge", graph.is_backward_edge);
@@ -56,6 +59,7 @@ inline void write(storage::tar::FileWriter &writer,
     storage::serialization::write(writer, name + "/node_array", graph.node_array);
     storage::serialization::write(writer, name + "/node_weights", graph.node_weights);
     storage::serialization::write(writer, name + "/node_durations", graph.node_durations);
+    storage::serialization::write(writer, name + "/node_distances", graph.node_distances);
     storage::serialization::write(writer, name + "/edge_array", graph.edge_array);
     storage::serialization::write(writer, name + "/is_forward_edge", graph.is_forward_edge);
     storage::serialization::write(writer, name + "/is_backward_edge", graph.is_backward_edge);

include/engine/api/table_parameters.hpp

@@ -59,6 +59,7 @@ struct TableParameters : public BaseParameters
 {
     std::vector<std::size_t> sources;
     std::vector<std::size_t> destinations;
+    std::size_t noroute_estimate = 0;
 
     enum class AnnotationsType
     {
@@ -74,19 +75,22 @@ struct TableParameters : public BaseParameters
     template <typename... Args>
     TableParameters(std::vector<std::size_t> sources_,
                     std::vector<std::size_t> destinations_,
+                    std::size_t noroute_estimate_,
                     Args... args_)
         : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
-          destinations{std::move(destinations_)}
+          destinations{std::move(destinations_)}, noroute_estimate{noroute_estimate_}
     {
     }
 
     template <typename... Args>
     TableParameters(std::vector<std::size_t> sources_,
                     std::vector<std::size_t> destinations_,
+                    std::size_t noroute_estimate_,
                     const AnnotationsType annotations_,
                     Args... args_)
         : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
-          destinations{std::move(destinations_)}, annotations{annotations_}
+          destinations{std::move(destinations_)}, noroute_estimate{noroute_estimate_},
+          annotations{annotations_}
     {
     }
 

include/engine/datafacade/algorithm_datafacade.hpp

@@ -78,6 +78,8 @@ template <> class AlgorithmDataFacade<MLD>
 
     virtual EdgeWeight GetNodeDuration(const NodeID node) const = 0; // TODO: to be removed
 
+    virtual EdgeDistance GetNodeDistance(const NodeID node) const = 0;
+
     virtual bool IsForwardEdge(EdgeID edge) const = 0;
 
     virtual bool IsBackwardEdge(EdgeID edge) const = 0;

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -697,6 +697,11 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
         return query_graph.GetNodeDuration(node);
     }
 
+    EdgeDistance GetNodeDistance(const NodeID node) const override final
+    {
+        return query_graph.GetNodeDistance(node);
+    }
+
     bool IsForwardEdge(const NodeID node) const override final
     {
         return query_graph.IsForwardEdge(node);

include/engine/datafacade_provider.hpp

@@ -93,7 +93,7 @@ class WatchingProvider : public DataFacadeProvider<AlgorithmT, FacadeT>
         return watchdog.Get(params);
     }
 };
-} // namespace detail
+}
 
 template <typename AlgorithmT>
 using DataFacadeProvider = detail::DataFacadeProvider<AlgorithmT, DataFacade>;
@@ -103,7 +103,7 @@ template <typename AlgorithmT>
 using ImmutableProvider = detail::ImmutableProvider<AlgorithmT, DataFacade>;
 template <typename AlgorithmT>
 using ExternalProvider = detail::ExternalProvider<AlgorithmT, DataFacade>;
-} // namespace engine
-} // namespace osrm
+}
+}
 
 #endif

include/engine/engine.hpp

@@ -138,7 +138,7 @@ template <typename Algorithm> class Engine final : public EngineInterface
     const plugins::MatchPlugin match_plugin;
     const plugins::TilePlugin tile_plugin;
 };
-} // namespace engine
-} // namespace osrm
+}
+}
 
 #endif // OSRM_IMPL_HPP

include/engine/engine_config.hpp

@@ -94,7 +94,7 @@ struct EngineConfig final
     std::string verbosity;
     std::string dataset_name;
 };
-} // namespace engine
-} // namespace osrm
+}
+}
 
 #endif // SERVER_CONFIG_HPP

include/engine/phantom_node.hpp

@@ -34,8 +34,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "util/coordinate.hpp"
 #include "util/typedefs.hpp"
 
-#include <iostream>
-
 #include <boost/assert.hpp>
 
 namespace osrm
@@ -236,7 +234,7 @@ struct PhantomNodes
     PhantomNode source_phantom;
     PhantomNode target_phantom;
 };
-} // namespace engine
-} // namespace osrm
+}
+}
 
 #endif // PHANTOM_NODES_H

include/engine/routing_algorithms.hpp

@@ -34,8 +34,7 @@ class RoutingAlgorithmsInterface
     ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
                      const std::vector<std::size_t> &source_indices,
                      const std::vector<std::size_t> &target_indices,
-                     const bool calculate_distance,
-                     const bool calculate_duration) const = 0;
+                     const bool calculate_distance) const = 0;
 
     virtual routing_algorithms::SubMatchingList
     MapMatching(const routing_algorithms::CandidateLists &candidates_list,
@@ -88,8 +87,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
     ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
                      const std::vector<std::size_t> &source_indices,
                      const std::vector<std::size_t> &target_indices,
-                     const bool calculate_distance,
-                     const bool calculate_duration) const final override;
+                     const bool calculate_distance) const final override;
 
     routing_algorithms::SubMatchingList
     MapMatching(const routing_algorithms::CandidateLists &candidates_list,
@@ -198,8 +196,7 @@ std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
 RoutingAlgorithms<Algorithm>::ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
                                                const std::vector<std::size_t> &_source_indices,
                                                const std::vector<std::size_t> &_target_indices,
-                                               const bool calculate_distance,
-                                               const bool calculate_duration) const
+                                               const bool calculate_distance) const
 {
     BOOST_ASSERT(!phantom_nodes.empty());
 
@@ -222,8 +219,7 @@ RoutingAlgorithms<Algorithm>::ManyToManySearch(const std::vector<PhantomNode> &p
                                                 phantom_nodes,
                                                 std::move(source_indices),
                                                 std::move(target_indices),
-                                                calculate_distance,
-                                                calculate_duration);
+                                                calculate_distance);
 }
 
 template <typename Algorithm>

include/engine/routing_algorithms/many_to_many.hpp

@@ -97,8 +97,7 @@ manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                  const std::vector<PhantomNode> &phantom_nodes,
                  const std::vector<std::size_t> &source_indices,
                  const std::vector<std::size_t> &target_indices,
-                 const bool calculate_distance,
-                 const bool calculate_duration);
+                 const bool calculate_distance);
 
 } // namespace routing_algorithms
 } // namespace engine

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -509,90 +509,6 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
     return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
 }
 
-// With (s, middle, t) we trace back the paths middle -> s and middle -> t.
-// This gives us a packed path (node ids) from the base graph around s and t,
-// and overlay node ids otherwise. We then have to unpack the overlay clique
-// edges by recursively descending unpacking the path down to the base graph.
-
-using UnpackedNodes = std::vector<NodeID>;
-using UnpackedEdges = std::vector<EdgeID>;
-using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
-
-template <typename Algorithm, typename... Args>
-UnpackedPath
-unpackPathAndCalculateDistance(SearchEngineData<Algorithm> &engine_working_data,
-                               const DataFacade<Algorithm> &facade,
-                               typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                               typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                               const bool force_loop_forward,
-                               const bool force_loop_reverse,
-                               EdgeWeight weight_upper_bound,
-                               PackedPath packed_path,
-                               NodeID middle,
-                               Args... args)
-{
-    EdgeWeight weight = weight_upper_bound;
-    const auto &partition = facade.GetMultiLevelPartition();
-    const NodeID source_node = !packed_path.empty() ? std::get<0>(packed_path.front()) : middle;
-
-    // Unpack path
-    std::vector<NodeID> unpacked_nodes;
-    std::vector<EdgeID> unpacked_edges;
-    unpacked_nodes.reserve(packed_path.size());
-    unpacked_edges.reserve(packed_path.size());
-
-    unpacked_nodes.push_back(source_node);
-
-    for (auto const &packed_edge : packed_path)
-    {
-        NodeID source, target;
-        bool overlay_edge;
-        std::tie(source, target, overlay_edge) = packed_edge;
-        if (!overlay_edge)
-        { // a base graph edge
-            unpacked_nodes.push_back(target);
-            unpacked_edges.push_back(facade.FindEdge(source, target));
-        }
-        else
-        { // an overlay graph edge
-            LevelID level = getNodeQueryLevel(partition, source, args...);
-            CellID parent_cell_id = partition.GetCell(level, source);
-            BOOST_ASSERT(parent_cell_id == partition.GetCell(level, target));
-
-            LevelID sublevel = level - 1;
-
-            // Here heaps can be reused, let's go deeper!
-            forward_heap.Clear();
-            reverse_heap.Clear();
-            forward_heap.Insert(source, 0, {source});
-            reverse_heap.Insert(target, 0, {target});
-
-            // TODO: when structured bindings will be allowed change to
-            // auto [subpath_weight, subpath_source, subpath_target, subpath] = ...
-            EdgeWeight subpath_weight;
-            std::vector<NodeID> subpath_nodes;
-            std::vector<EdgeID> subpath_edges;
-            std::tie(subpath_weight, subpath_nodes, subpath_edges) = search(engine_working_data,
-                                                                            facade,
-                                                                            forward_heap,
-                                                                            reverse_heap,
-                                                                            force_loop_forward,
-                                                                            force_loop_reverse,
-                                                                            weight_upper_bound,
-                                                                            sublevel,
-                                                                            parent_cell_id);
-            BOOST_ASSERT(!subpath_edges.empty());
-            BOOST_ASSERT(subpath_nodes.size() > 1);
-            BOOST_ASSERT(subpath_nodes.front() == source);
-            BOOST_ASSERT(subpath_nodes.back() == target);
-            unpacked_nodes.insert(
-                unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
-            unpacked_edges.insert(unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
-        }
-    }
-    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
-}
-
 // Alias to be compatible with the CH-based search
 template <typename Algorithm>
 inline void search(SearchEngineData<Algorithm> &engine_working_data,

include/engine/search_engine_data.hpp

@@ -120,7 +120,7 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
     void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
                                                        unsigned number_of_boundary_nodes);
 };
-} // namespace engine
-} // namespace osrm
+}
+}
 
 #endif // SEARCH_ENGINE_DATA_HPP

include/extractor/compressed_edge_container.hpp

@@ -82,7 +82,7 @@ class CompressedEdgeContainer
     std::unordered_map<EdgeID, unsigned> m_reverse_edge_id_to_zipped_index_map;
     std::unique_ptr<SegmentDataContainer> segment_data;
 };
-} // namespace extractor
-} // namespace osrm
+}
+}
 
 #endif // GEOMETRY_COMPRESSOR_HPP_

include/extractor/edge_based_edge.hpp

@@ -96,7 +96,7 @@ inline bool EdgeBasedEdge::operator<(const EdgeBasedEdge &other) const
     return std::tie(source, target, data.weight, unidirectional) <
            std::tie(other.source, other.target, other.data.weight, other_is_unidirectional);
 }
-} // namespace extractor
-} // namespace osrm
+} // ns extractor
+} // ns osrm
 
 #endif /* EDGE_BASED_EDGE_HPP */

include/extractor/edge_based_graph_factory.hpp

@@ -92,6 +92,7 @@ class EdgeBasedGraphFactory
     void GetStartPointMarkers(std::vector<bool> &node_is_startpoint);
     void GetEdgeBasedNodeWeights(std::vector<EdgeWeight> &output_node_weights);
     void GetEdgeBasedNodeDurations(std::vector<EdgeWeight> &output_node_durations);
+    void GetEdgeBasedNodeDistances(std::vector<EdgeDistance> &output_node_distances);
     std::uint32_t GetConnectivityChecksum() const;
 
     std::uint64_t GetNumberOfEdgeBasedNodes() const;
@@ -119,6 +120,7 @@ class EdgeBasedGraphFactory
     //! edge-based node
     std::vector<EdgeWeight> m_edge_based_node_weights;
     std::vector<EdgeDuration> m_edge_based_node_durations;
+    std::vector<EdgeDistance> m_edge_based_node_distances;
 
     //! list of edge based nodes (compressed segments)
     std::vector<EdgeBasedNodeSegment> m_edge_based_node_segments;

include/extractor/extractor.hpp

@@ -88,6 +88,7 @@ class Extractor
         std::vector<bool> &node_is_startpoint,
         std::vector<EdgeWeight> &edge_based_node_weights,
         std::vector<EdgeDuration> &edge_based_node_durations,
+        std::vector<EdgeDistance> &edge_based_node_distances,
         util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
         std::uint32_t &connectivity_checksum);
 

include/extractor/files.hpp

@@ -453,8 +453,8 @@ void writeNames(const boost::filesystem::path &path, const NameTableT &table)
     serialization::write(writer, "/common/names", table);
 }
 
-template <typename NodeWeigtsVectorT>
-void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeigtsVectorT &weights)
+template <typename NodeWeightsVectorT>
+void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVectorT &weights)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -462,9 +462,33 @@ void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeigtsVec
     storage::serialization::read(reader, "/extractor/edge_based_node_weights", weights);
 }
 
-template <typename NodeWeigtsVectorT, typename NodeDurationsVectorT>
+template <typename NodeDistancesVectorT>
+void readEdgeBasedNodeDistances(const boost::filesystem::path &path,
+                                NodeDistancesVectorT &distances)
+{
+    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
+    storage::tar::FileReader reader{path, fingerprint};
+
+    storage::serialization::read(reader, "/extractor/edge_based_node_distances", distances);
+}
+
+template <typename NodeWeightsVectorT, typename NodeDurationsVectorT, typename NodeDistancesVectorT>
+void writeEdgeBasedNodeWeightsDurationsDistances(const boost::filesystem::path &path,
+                                                 const NodeWeightsVectorT &weights,
+                                                 const NodeDurationsVectorT &durations,
+                                                 const NodeDistancesVectorT &distances)
+{
+    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
+    storage::tar::FileWriter writer{path, fingerprint};
+
+    storage::serialization::write(writer, "/extractor/edge_based_node_weights", weights);
+    storage::serialization::write(writer, "/extractor/edge_based_node_durations", durations);
+    storage::serialization::write(writer, "/extractor/edge_based_node_distances", distances);
+}
+
+template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
 void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
-                                       NodeWeigtsVectorT &weights,
+                                       NodeWeightsVectorT &weights,
                                        NodeDurationsVectorT &durations)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@@ -474,9 +498,9 @@ void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
     storage::serialization::read(reader, "/extractor/edge_based_node_durations", durations);
 }
 
-template <typename NodeWeigtsVectorT, typename NodeDurationsVectorT>
+template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
 void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
-                                        const NodeWeigtsVectorT &weights,
+                                        const NodeWeightsVectorT &weights,
                                         const NodeDurationsVectorT &durations)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;

include/extractor/internal_extractor_edge.hpp

@@ -49,7 +49,7 @@ struct ByEdgeOrByMeterValue
     using value_type = float;
     value_type value;
 };
-} // namespace detail
+}
 
 struct InternalExtractorEdge
 {
@@ -113,7 +113,7 @@ struct InternalExtractorEdge
         return v;
     }
 };
-} // namespace extractor
-} // namespace osrm
+}
+}
 
 #endif // INTERNAL_EXTRACTOR_EDGE_HPP

include/extractor/node_based_edge.hpp

@@ -206,7 +206,7 @@ static_assert(sizeof(extractor::NodeBasedEdge) == 32,
               "bigger than expected. This will influence "
               "memory consumption.");
 
-} // namespace extractor
-} // namespace osrm
+} // ns extractor
+} // ns osrm
 
 #endif /* NODE_BASED_EDGE_HPP */

include/nodejs/node_osrm_support.hpp

@@ -1183,6 +1183,19 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         }
     }
 
+    if (obj->Has(Nan::New("noroute_estimate").ToLocalChecked()))
+    {
+        auto noroute_estimate = obj->Get(Nan::New("noroute_estimate").ToLocalChecked());
+
+        if (!noroute_estimate->IsNumber() && !noroute_estimate->IsUint32())
+        {
+            Nan::ThrowError("noroute_estimate must be an integral number");
+            return table_parameters_ptr();
+        }
+
+        params->noroute_estimate = static_cast<size_t>(noroute_estimate->NumberValue());
+    }
+
     return params;
 }
 

include/partitioner/cell_storage.hpp

@@ -75,28 +75,35 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
     // Implementation of the cell view. We need a template parameter here
     // because we need to derive a read-only and read-write view from this.
-    template <typename WeightValueT, typename DurationValueT> class CellImpl
+    template <typename WeightValueT, typename DurationValueT, typename DistanceValueT>
+    class CellImpl
     {
       private:
         using WeightPtrT = WeightValueT *;
         using DurationPtrT = DurationValueT *;
+        using DistancePtrT = DistanceValueT *;
         BoundarySize num_source_nodes;
         BoundarySize num_destination_nodes;
 
         WeightPtrT const weights;
         DurationPtrT const durations;
+        DistancePtrT const distances;
         const NodeID *const source_boundary;
         const NodeID *const destination_boundary;
 
         using RowIterator = WeightPtrT;
         // Possibly replace with
         // http://www.boost.org/doc/libs/1_55_0/libs/range/doc/html/range/reference/adaptors/reference/strided.html
-        class ColumnIterator : public boost::iterator_facade<ColumnIterator,
-                                                             WeightValueT,
+
+        template <typename ValuePtrT>
+        class ColumnIterator : public boost::iterator_facade<ColumnIterator<ValuePtrT>,
+                                                             decltype(*std::declval<ValuePtrT>()),
                                                              boost::random_access_traversal_tag>
         {
-            typedef boost::iterator_facade<ColumnIterator,
-                                           WeightValueT,
+
+            using ValueT = decltype(*std::declval<ValuePtrT>());
+            typedef boost::iterator_facade<ColumnIterator<ValueT>,
+                                           ValueT,
                                            boost::random_access_traversal_tag>
                 base_t;
 
@@ -108,7 +115,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
             explicit ColumnIterator() : current(nullptr), stride(1) {}
 
-            explicit ColumnIterator(WeightPtrT begin, std::size_t row_length)
+            explicit ColumnIterator(ValuePtrT begin, std::size_t row_length)
                 : current(begin), stride(row_length)
             {
                 BOOST_ASSERT(begin != nullptr);
@@ -126,7 +133,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
             }
 
             friend class ::boost::iterator_core_access;
-            WeightPtrT current;
+            ValuePtrT current;
             const std::size_t stride;
         };
 
@@ -147,12 +154,13 @@ template <storage::Ownership Ownership> class CellStorageImpl
             auto iter =
                 std::find(destination_boundary, destination_boundary + num_destination_nodes, node);
             if (iter == destination_boundary + num_destination_nodes)
-                return boost::make_iterator_range(ColumnIterator{}, ColumnIterator{});
+                return boost::make_iterator_range(ColumnIterator<ValuePtr>{},
+                                                  ColumnIterator<ValuePtr>{});
 
             auto column = std::distance(destination_boundary, iter);
-            auto begin = ColumnIterator{ptr + column, num_destination_nodes};
-            auto end = ColumnIterator{ptr + column + num_source_nodes * num_destination_nodes,
-                                      num_destination_nodes};
+            auto begin = ColumnIterator<ValuePtr>{ptr + column, num_destination_nodes};
+            auto end = ColumnIterator<ValuePtr>{
+                ptr + column + num_source_nodes * num_destination_nodes, num_destination_nodes};
             return boost::make_iterator_range(begin, end);
         }
 
@@ -165,6 +173,10 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
         auto GetInDuration(NodeID node) const { return GetInRange(durations, node); }
 
+        auto GetInDistance(NodeID node) const { return GetInRange(distances, node); }
+
+        auto GetOutDistance(NodeID node) const { return GetOutRange(distances, node); }
+
         auto GetSourceNodes() const
         {
             return boost::make_iterator_range(source_boundary, source_boundary + num_source_nodes);
@@ -179,17 +191,20 @@ template <storage::Ownership Ownership> class CellStorageImpl
         CellImpl(const CellData &data,
                  WeightPtrT const all_weights,
                  DurationPtrT const all_durations,
+                 DistancePtrT const all_distances,
                  const NodeID *const all_sources,
                  const NodeID *const all_destinations)
             : num_source_nodes{data.num_source_nodes},
               num_destination_nodes{data.num_destination_nodes},
               weights{all_weights + data.value_offset},
               durations{all_durations + data.value_offset},
+              distances{all_distances + data.value_offset},
               source_boundary{all_sources + data.source_boundary_offset},
               destination_boundary{all_destinations + data.destination_boundary_offset}
         {
             BOOST_ASSERT(all_weights != nullptr);
             BOOST_ASSERT(all_durations != nullptr);
+            BOOST_ASSERT(all_distances != nullptr);
             BOOST_ASSERT(num_source_nodes == 0 || all_sources != nullptr);
             BOOST_ASSERT(num_destination_nodes == 0 || all_destinations != nullptr);
         }
@@ -201,7 +216,8 @@ template <storage::Ownership Ownership> class CellStorageImpl
                  const NodeID *const all_destinations)
             : num_source_nodes{data.num_source_nodes},
               num_destination_nodes{data.num_destination_nodes}, weights{nullptr},
-              durations{nullptr}, source_boundary{all_sources + data.source_boundary_offset},
+              durations{nullptr}, distances{nullptr},
+              source_boundary{all_sources + data.source_boundary_offset},
               destination_boundary{all_destinations + data.destination_boundary_offset}
         {
             BOOST_ASSERT(num_source_nodes == 0 || all_sources != nullptr);
@@ -212,8 +228,8 @@ template <storage::Ownership Ownership> class CellStorageImpl
     std::size_t LevelIDToIndex(LevelID level) const { return level - 1; }
 
   public:
-    using Cell = CellImpl<EdgeWeight, EdgeDuration>;
-    using ConstCell = CellImpl<const EdgeWeight, const EdgeDuration>;
+    using Cell = CellImpl<EdgeWeight, EdgeDuration, EdgeDistance>;
+    using ConstCell = CellImpl<const EdgeWeight, const EdgeDuration, const EdgeDistance>;
 
     CellStorageImpl() {}
 
@@ -361,6 +377,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
         metric.weights.resize(total_size + 1, INVALID_EDGE_WEIGHT);
         metric.durations.resize(total_size + 1, MAXIMAL_EDGE_DURATION);
+        metric.distances.resize(total_size + 1, INVALID_EDGE_DISTANCE);
 
         return metric;
     }
@@ -388,6 +405,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
         return ConstCell{cells[cell_index],
                          metric.weights.data(),
                          metric.durations.data(),
+                         metric.distances.data(),
                          source_boundary.empty() ? nullptr : source_boundary.data(),
                          destination_boundary.empty() ? nullptr : destination_boundary.data()};
     }
@@ -415,6 +433,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
         return Cell{cells[cell_index],
                     metric.weights.data(),
                     metric.durations.data(),
+                    metric.distances.data(),
                     source_boundary.data(),
                     destination_boundary.data()};
     }

include/partitioner/edge_based_graph_reader.hpp

@@ -14,8 +14,6 @@
 #include <tbb/parallel_for.h>
 #include <tbb/parallel_reduce.h>
 
-#include <iostream>
-
 #include <cstdint>
 
 #include <algorithm>
@@ -200,7 +198,7 @@ inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const boost::filesystem::path &p
     return DynamicEdgeBasedGraph(number_of_edge_based_nodes, std::move(tidied), checksum);
 }
 
-} // namespace partitioner
-} // namespace osrm
+} // ns partition
+} // ns osrm
 
 #endif

include/server/api/table_parameter_grammar.hpp

@@ -48,10 +48,16 @@ struct TableParametersGrammar : public BaseParametersGrammar<Iterator, Signature
             (qi::lit("all") |
              (size_t_ % ';')[ph::bind(&engine::api::TableParameters::sources, qi::_r1) = qi::_1]);
 
+        noroute_estimate_rule =
+            qi::lit("noroute_estimate=") >
+            (size_t_)[ph::bind(&engine::api::TableParameters::noroute_estimate, qi::_r1) = qi::_1];
+
         table_rule = destinations_rule(qi::_r1) | sources_rule(qi::_r1);
 
-        root_rule = BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
-                    -('?' > (table_rule(qi::_r1) | base_rule(qi::_r1)) % '&');
+        root_rule =
+            BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
+            -('?' >
+              (table_rule(qi::_r1) | base_rule(qi::_r1) | noroute_estimate_rule(qi::_r1)) % '&');
     }
 
     TableParametersGrammar(qi::rule<Iterator, Signature> &root_rule_) : BaseGrammar(root_rule_)
@@ -77,6 +83,7 @@ struct TableParametersGrammar : public BaseParametersGrammar<Iterator, Signature
     qi::rule<Iterator, Signature> table_rule;
     qi::rule<Iterator, Signature> sources_rule;
     qi::rule<Iterator, Signature> destinations_rule;
+    qi::rule<Iterator, Signature> noroute_estimate_rule;
     qi::rule<Iterator, std::size_t()> size_t_;
     qi::symbols<char, engine::api::TableParameters::AnnotationsType> annotations;
     qi::rule<Iterator, engine::api::TableParameters::AnnotationsType()> annotations_list;

include/storage/serialization.hpp

@@ -9,6 +9,7 @@
 #include "storage/shared_datatype.hpp"
 #include "storage/tar.hpp"
 
+#include <boost/assert.hpp>
 #include <boost/function_output_iterator.hpp>
 #include <boost/iterator/function_input_iterator.hpp>
 
@@ -33,6 +34,10 @@ template <typename T, typename BlockT = unsigned char>
 inline BlockT packBits(const T &data, std::size_t base_index, const std::size_t count)
 {
     static_assert(std::is_same<typename T::value_type, bool>::value, "value_type is not bool");
+    static_assert(std::is_unsigned<BlockT>::value, "BlockT must be unsigned type");
+    static_assert(std::is_integral<BlockT>::value, "BlockT must be an integral type");
+    static_assert(CHAR_BIT == 8, "Non-8-bit bytes not supported, sorry!");
+    BOOST_ASSERT(sizeof(BlockT) * CHAR_BIT >= count);
 
     // Note: if this packing is changed, be sure to update vector_view<bool>
     //       as well, so that on-disk and in-memory layouts match.
@@ -49,6 +54,10 @@ inline void
 unpackBits(T &data, const std::size_t base_index, const std::size_t count, const BlockT value)
 {
     static_assert(std::is_same<typename T::value_type, bool>::value, "value_type is not bool");
+    static_assert(std::is_unsigned<BlockT>::value, "BlockT must be unsigned type");
+    static_assert(std::is_integral<BlockT>::value, "BlockT must be an integral type");
+    static_assert(CHAR_BIT == 8, "Non-8-bit bytes not supported, sorry!");
+    BOOST_ASSERT(sizeof(BlockT) * CHAR_BIT >= count);
     for (std::size_t bit = 0; bit < count; ++bit)
     {
         data[base_index + bit] = value & (BlockT{1} << bit);
@@ -62,15 +71,16 @@ void readBoolVector(tar::FileReader &reader, const std::string &name, VectorT &d
     data.resize(count);
     std::uint64_t index = 0;
 
-    constexpr std::uint64_t WORD_BITS = CHAR_BIT * sizeof(std::uint64_t);
+    using BlockType = std::uint64_t;
+    constexpr std::uint64_t BLOCK_BITS = CHAR_BIT * sizeof(BlockType);
 
-    const auto decode = [&](const std::uint64_t block) {
-        auto read_size = std::min<std::size_t>(count - index, WORD_BITS);
-        unpackBits<VectorT, std::uint64_t>(data, index, read_size, block);
-        index += WORD_BITS;
+    const auto decode = [&](const BlockType block) {
+        auto read_size = std::min<std::size_t>(count - index, BLOCK_BITS);
+        unpackBits<VectorT, BlockType>(data, index, read_size, block);
+        index += BLOCK_BITS;
     };
 
-    reader.ReadStreaming<std::uint64_t>(name, boost::make_function_output_iterator(decode));
+    reader.ReadStreaming<BlockType>(name, boost::make_function_output_iterator(decode));
 }
 
 template <typename VectorT>
@@ -80,24 +90,25 @@ void writeBoolVector(tar::FileWriter &writer, const std::string &name, const Vec
     writer.WriteElementCount64(name, count);
     std::uint64_t index = 0;
 
-    constexpr std::uint64_t WORD_BITS = CHAR_BIT * sizeof(std::uint64_t);
+    using BlockType = std::uint64_t;
+    constexpr std::uint64_t BLOCK_BITS = CHAR_BIT * sizeof(BlockType);
 
     // FIXME on old boost version the function_input_iterator does not work with lambdas
     // so we need to wrap it in a function here.
-    const std::function<std::uint64_t()> encode_function = [&]() -> std::uint64_t {
-        auto write_size = std::min<std::size_t>(count - index, WORD_BITS);
-        auto packed = packBits<VectorT, std::uint64_t>(data, index, write_size);
-        index += WORD_BITS;
+    const std::function<BlockType()> encode_function = [&]() -> BlockType {
+        auto write_size = std::min<std::size_t>(count - index, BLOCK_BITS);
+        auto packed = packBits<VectorT, BlockType>(data, index, write_size);
+        index += BLOCK_BITS;
         return packed;
     };
 
-    std::uint64_t number_of_blocks = (count + WORD_BITS - 1) / WORD_BITS;
-    writer.WriteStreaming<std::uint64_t>(
+    std::uint64_t number_of_blocks = (count + BLOCK_BITS - 1) / BLOCK_BITS;
+    writer.WriteStreaming<BlockType>(
         name,
         boost::make_function_input_iterator(encode_function, boost::infinite()),
         number_of_blocks);
 }
-} // namespace detail
+}
 
 /* All vector formats here use the same on-disk format.
  * This is important because we want to be able to write from a vector
@@ -273,17 +284,14 @@ template <typename K, typename V> void write(io::BufferWriter &writer, const std
     }
 }
 
-inline void read(io::BufferReader &reader, std::unique_ptr<BaseDataLayout> &layout)
-{
-    read(reader, layout->blocks);
-}
+inline void read(io::BufferReader &reader, BaseDataLayout &layout) { read(reader, layout.blocks); }
 
-inline void write(io::BufferWriter &writer, const std::unique_ptr<BaseDataLayout> &layout)
+inline void write(io::BufferWriter &writer, const BaseDataLayout &layout)
 {
-    write(writer, layout->blocks);
+    write(writer, layout.blocks);
+}
+}
+}
 }
-} // namespace serialization
-} // namespace storage
-} // namespace osrm
 
 #endif

include/storage/shared_data_index.hpp

@@ -5,6 +5,7 @@
 
 #include <boost/function_output_iterator.hpp>
 
+#include <type_traits>
 #include <unordered_map>
 
 namespace osrm
@@ -19,7 +20,7 @@ class SharedDataIndex
   public:
     struct AllocatedRegion
     {
-        char *memory_ptr;
+        void *memory_ptr;
         std::unique_ptr<BaseDataLayout> layout;
     };
 
@@ -46,12 +47,24 @@ class SharedDataIndex
 
     template <typename T> auto GetBlockPtr(const std::string &name) const
     {
+#if !defined(__GNUC__) || (__GNUC__ > 4)
+        // is_tivially_copyable only exists in GCC >=5
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Block-based data must be a trivially copyable type");
+        static_assert(sizeof(T) % alignof(T) == 0, "aligned T* can't be used as an array pointer");
+#endif
         const auto &region = GetBlockRegion(name);
         return reinterpret_cast<T *>(region.layout->GetBlockPtr(region.memory_ptr, name));
     }
 
     template <typename T> auto GetBlockPtr(const std::string &name)
     {
+#if !defined(__GNUC__) || (__GNUC__ > 4)
+        // is_tivially_copyable only exists in GCC >=5
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Block-based data must be a trivially copyable type");
+        static_assert(sizeof(T) % alignof(T) == 0, "aligned T* can't be used as an array pointer");
+#endif
         const auto &region = GetBlockRegion(name);
         return reinterpret_cast<T *>(region.layout->GetBlockPtr(region.memory_ptr, name));
     }

include/storage/shared_datatype.hpp

@@ -23,9 +23,9 @@ namespace storage
 class BaseDataLayout;
 namespace serialization
 {
-inline void read(io::BufferReader &reader, std::unique_ptr<BaseDataLayout> &layout);
+inline void read(io::BufferReader &reader, BaseDataLayout &layout);
 
-inline void write(io::BufferWriter &writer, const std::unique_ptr<BaseDataLayout> &layout);
+inline void write(io::BufferWriter &writer, const BaseDataLayout &layout);
 } // namespace serialization
 
 namespace detail
@@ -59,15 +59,22 @@ class BaseDataLayout
   public:
     virtual ~BaseDataLayout() = default;
 
-    virtual inline void SetBlock(const std::string &name, Block block) = 0;
+    inline void SetBlock(const std::string &name, Block block) { blocks[name] = std::move(block); }
 
-    virtual inline uint64_t GetBlockEntries(const std::string &name) const = 0;
+    inline std::uint64_t GetBlockEntries(const std::string &name) const
+    {
+        return GetBlock(name).num_entries;
+    }
 
-    virtual inline uint64_t GetBlockSize(const std::string &name) const = 0;
+    inline std::uint64_t GetBlockSize(const std::string &name) const
+    {
+        return GetBlock(name).byte_size;
+    }
 
-    virtual inline bool HasBlock(const std::string &name) const = 0;
-
-    virtual inline uint64_t GetSizeOfLayout() const = 0;
+    inline bool HasBlock(const std::string &name) const
+    {
+        return blocks.find(name) != blocks.end();
+    }
 
     // Depending on the name prefix this function either lists all blocks with the same prefix
     // or all entries in the sub-directory.
@@ -92,60 +99,10 @@ class BaseDataLayout
         }
     }
 
-    virtual inline void *GetBlockPtr(char *shared_memory, const std::string &name) const = 0;
-
-    std::map<std::string, Block> blocks;
-};
-
-class DataLayout final : public BaseDataLayout
-{
-  public:
-    inline void SetBlock(const std::string &name, Block block) override final
-    {
-        blocks[name] = std::move(block);
-    }
-
-    inline uint64_t GetBlockEntries(const std::string &name) const override final
-    {
-        return GetBlock(name).num_entries;
-    }
-
-    inline uint64_t GetBlockSize(const std::string &name) const override final
-    {
-        return GetBlock(name).byte_size;
-    }
-
-    inline bool HasBlock(const std::string &name) const override final
-    {
-        return blocks.find(name) != blocks.end();
-    }
-
-    inline uint64_t GetSizeOfLayout() const override final
-    {
-        uint64_t result = 0;
-        for (const auto &name_and_block : blocks)
-        {
-            result += GetBlockSize(name_and_block.first) + BLOCK_ALIGNMENT;
-        }
-        return result;
-    }
-
-    inline void *GetBlockPtr(char *shared_memory, const std::string &name) const override final
-    {
-        // TODO: re-enable this alignment checking somehow
-        // static_assert(BLOCK_ALIGNMENT % std::alignment_of<T>::value == 0,
-        //               "Datatype does not fit alignment constraints.");
-
-        char *ptr = (char *)GetAlignedBlockPtr(shared_memory, name);
-        return ptr;
-    }
-
-  private:
-    friend void serialization::read(io::BufferReader &reader,
-                                    std::unique_ptr<BaseDataLayout> &layout);
-    friend void serialization::write(io::BufferWriter &writer,
-                                     const std::unique_ptr<BaseDataLayout> &layout);
+    virtual inline void *GetBlockPtr(void *base_ptr, const std::string &name) const = 0;
+    virtual inline std::uint64_t GetSizeOfLayout() const = 0;
 
+  protected:
     const Block &GetBlock(const std::string &name) const
     {
         auto iter = blocks.find(name);
@@ -157,10 +114,42 @@ class DataLayout final : public BaseDataLayout
         return iter->second;
     }
 
+    friend void serialization::read(io::BufferReader &reader, BaseDataLayout &layout);
+    friend void serialization::write(io::BufferWriter &writer, const BaseDataLayout &layout);
+
+    std::map<std::string, Block> blocks;
+};
+
+class ContiguousDataLayout final : public BaseDataLayout
+{
+  public:
+    inline std::uint64_t GetSizeOfLayout() const override final
+    {
+        std::uint64_t result = 0;
+        for (const auto &name_and_block : blocks)
+        {
+            result += GetBlockSize(name_and_block.first) + BLOCK_ALIGNMENT;
+        }
+        return result;
+    }
+
+    inline void *GetBlockPtr(void *base_ptr, const std::string &name) const override final
+    {
+        // TODO: re-enable this alignment checking somehow
+        // static_assert(BLOCK_ALIGNMENT % std::alignment_of<T>::value == 0,
+        //               "Datatype does not fit alignment constraints.");
+
+        return GetAlignedBlockPtr(base_ptr, name);
+    }
+
+  private:
+    friend void serialization::read(io::BufferReader &reader, BaseDataLayout &layout);
+    friend void serialization::write(io::BufferWriter &writer, const BaseDataLayout &layout);
+
     // Fit aligned storage in buffer to 64 bytes to conform with AVX 512 types
     inline void *align(void *&ptr) const noexcept
     {
-        const auto intptr = reinterpret_cast<uintptr_t>(ptr);
+        const auto intptr = reinterpret_cast<std::uintptr_t>(ptr);
         const auto aligned = (intptr - 1u + BLOCK_ALIGNMENT) & -BLOCK_ALIGNMENT;
         return ptr = reinterpret_cast<void *>(aligned);
     }
@@ -189,29 +178,9 @@ class DataLayout final : public BaseDataLayout
 class TarDataLayout final : public BaseDataLayout
 {
   public:
-    inline void SetBlock(const std::string &name, Block block) override final
+    inline std::uint64_t GetSizeOfLayout() const override final
     {
-        blocks[name] = std::move(block);
-    }
-
-    inline uint64_t GetBlockEntries(const std::string &name) const override final
-    {
-        return GetBlock(name).num_entries;
-    }
-
-    inline uint64_t GetBlockSize(const std::string &name) const override final
-    {
-        return GetBlock(name).byte_size;
-    }
-
-    inline bool HasBlock(const std::string &name) const override final
-    {
-        return blocks.find(name) != blocks.end();
-    }
-
-    inline uint64_t GetSizeOfLayout() const override final
-    {
-        uint64_t result = 0;
+        std::uint64_t result = 0;
         for (const auto &name_and_block : blocks)
         {
             result += GetBlockSize(name_and_block.first);
@@ -219,28 +188,11 @@ class TarDataLayout final : public BaseDataLayout
         return result;
     }
 
-    inline void *GetBlockPtr(char *memory_ptr, const std::string &name) const override final
+    inline void *GetBlockPtr(void *base_ptr, const std::string &name) const override final
     {
         auto offset = GetBlock(name).offset;
-        const auto offset_memory = memory_ptr + offset;
-        return offset_memory;
-    }
-
-  private:
-    friend void serialization::read(io::BufferReader &reader,
-                                    std::unique_ptr<BaseDataLayout> &layout);
-    friend void serialization::write(io::BufferWriter &writer,
-                                     const std::unique_ptr<BaseDataLayout> &layout);
-
-    const Block &GetBlock(const std::string &name) const
-    {
-        auto iter = blocks.find(name);
-        if (iter == blocks.end())
-        {
-            throw util::exception("Could not find block " + name);
-        }
-
-        return iter->second;
+        const auto offset_address = reinterpret_cast<std::uintptr_t>(base_ptr) + offset;
+        return reinterpret_cast<void *>(offset_address);
     }
 };
 

include/storage/storage.hpp

@@ -35,11 +35,15 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <boost/filesystem/path.hpp>
 
 #include <string>
+#include <vector>
 
 namespace osrm
 {
 namespace storage
 {
+
+void populateLayoutFromFile(const boost::filesystem::path &path, storage::BaseDataLayout &layout);
+
 class Storage
 {
   public:
@@ -48,11 +52,9 @@ class Storage
     int Run(int max_wait, const std::string &name, bool only_metric);
     void PopulateStaticData(const SharedDataIndex &index);
     void PopulateUpdatableData(const SharedDataIndex &index);
-    void PopulateLayout(std::unique_ptr<storage::BaseDataLayout> &layout,
-                        std::vector<std::pair<bool, boost::filesystem::path>> files);
-    std::string PopulateLayoutWithRTree(std::unique_ptr<storage::BaseDataLayout> &layout);
-    void readBlocks(const boost::filesystem::path &path,
-                    std::unique_ptr<storage::BaseDataLayout> &layout);
+    void PopulateLayout(storage::BaseDataLayout &layout,
+                        const std::vector<std::pair<bool, boost::filesystem::path>> &files);
+    std::string PopulateLayoutWithRTree(storage::BaseDataLayout &layout);
     std::vector<std::pair<bool, boost::filesystem::path>> GetUpdatableFiles();
     std::vector<std::pair<bool, boost::filesystem::path>> GetStaticFiles();
 

include/storage/view_factory.hpp

@@ -294,11 +294,14 @@ inline auto make_filtered_cell_metric_view(const SharedDataIndex &index,
     auto prefix = name + "/exclude/" + std::to_string(exclude_index);
     auto weights_block_id = prefix + "/weights";
     auto durations_block_id = prefix + "/durations";
+    auto distances_block_id = prefix + "/distances";
 
     auto weights = make_vector_view<EdgeWeight>(index, weights_block_id);
     auto durations = make_vector_view<EdgeDuration>(index, durations_block_id);
+    auto distances = make_vector_view<EdgeDistance>(index, distances_block_id);
 
-    return customizer::CellMetricView{std::move(weights), std::move(durations)};
+    return customizer::CellMetricView{
+        std::move(weights), std::move(durations), std::move(distances)};
 }
 
 inline auto make_cell_metric_view(const SharedDataIndex &index, const std::string &name)
@@ -311,12 +314,14 @@ inline auto make_cell_metric_view(const SharedDataIndex &index, const std::strin
     {
         auto weights_block_id = prefix + "/weights";
         auto durations_block_id = prefix + "/durations";
+        auto distances_block_id = prefix + "/distances";
 
         auto weights = make_vector_view<EdgeWeight>(index, weights_block_id);
         auto durations = make_vector_view<EdgeDuration>(index, durations_block_id);
+        auto distances = make_vector_view<EdgeDistance>(index, distances_block_id);
 
-        cell_metric_excludes.push_back(
-            customizer::CellMetricView{std::move(weights), std::move(durations)});
+        cell_metric_excludes.push_back(customizer::CellMetricView{
+            std::move(weights), std::move(durations), std::move(distances)});
     }
 
     return cell_metric_excludes;
@@ -332,6 +337,7 @@ inline auto make_multi_level_graph_view(const SharedDataIndex &index, const std:
         index, name + "/node_to_edge_offset");
     auto node_weights = make_vector_view<EdgeWeight>(index, name + "/node_weights");
     auto node_durations = make_vector_view<EdgeDuration>(index, name + "/node_durations");
+    auto node_distances = make_vector_view<EdgeDistance>(index, name + "/node_distances");
     auto is_forward_edge = make_vector_view<bool>(index, name + "/is_forward_edge");
     auto is_backward_edge = make_vector_view<bool>(index, name + "/is_backward_edge");
 
@@ -340,6 +346,7 @@ inline auto make_multi_level_graph_view(const SharedDataIndex &index, const std:
                                                     std::move(node_to_offset),
                                                     std::move(node_weights),
                                                     std::move(node_durations),
+                                                    std::move(node_distances),
                                                     std::move(is_forward_edge),
                                                     std::move(is_backward_edge));
 }

include/updater/updater.hpp

@@ -22,11 +22,17 @@ class Updater
                                    std::vector<EdgeWeight> &node_weights,
                                    std::uint32_t &connectivity_checksum) const;
 
-    EdgeID
-    LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &edge_based_edge_list,
-                                   std::vector<EdgeWeight> &node_weights,
-                                   std::vector<EdgeDuration> &node_durations, // TODO: to be deleted
-                                   std::uint32_t &connectivity_checksum) const;
+    EdgeID LoadAndUpdateEdgeExpandedGraph(
+        std::vector<extractor::EdgeBasedEdge> &edge_based_edge_list,
+        std::vector<EdgeWeight> &node_weights,
+        std::vector<EdgeDuration> &node_durations, // TODO: remove when optional
+        std::uint32_t &connectivity_checksum) const;
+    EdgeID LoadAndUpdateEdgeExpandedGraph(
+        std::vector<extractor::EdgeBasedEdge> &edge_based_edge_list,
+        std::vector<EdgeWeight> &node_weights,
+        std::vector<EdgeDuration> &node_durations, // TODO: remove when optional
+        std::vector<EdgeDistance> &node_distances, // TODO: remove when optional
+        std::uint32_t &connectivity_checksum) const;
 
   private:
     UpdaterConfig config;

include/util/debug.hpp

@@ -27,7 +27,7 @@ inline std::ostream &operator<<(std::ostream &out, const Coordinate &coordinate)
         << toFloating(coordinate.lat) << "}";
     return out;
 }
-} // namespace util
+}
 
 namespace engine
 {
@@ -62,8 +62,8 @@ inline std::ostream &operator<<(std::ostream &out, const RouteStep &step)
 
     return out;
 }
-} // namespace guidance
-} // namespace engine
+}
+}
 
 namespace guidance
 {
@@ -76,7 +76,7 @@ inline std::ostream &operator<<(std::ostream &out, const ConnectedRoad &road)
         << static_cast<std::int32_t>(road.lane_data_id) << "}";
     return out;
 }
-} // namespace guidance
+}
 
 namespace extractor
 {
@@ -95,7 +95,7 @@ inline std::ostream &operator<<(std::ostream &out, const IntersectionViewData &v
         << " angle: " << view.angle << " bearing: " << view.perceived_bearing << "}";
     return out;
 }
-} // namespace intersection
+}
 
 namespace TurnLaneType
 {
@@ -125,9 +125,9 @@ inline std::ostream &operator<<(std::ostream &out, const Mask lane_type)
 
     return out;
 }
-} // namespace TurnLaneType
-} // namespace extractor
-} // namespace osrm
+}
+}
+}
 
 namespace std
 {
@@ -147,7 +147,7 @@ inline std::ostream &operator<<(std::ostream &out,
 
     return out;
 }
-} // namespace std
+}
 
 namespace osrm
 {
@@ -186,8 +186,8 @@ inline std::ostream &operator<<(std::ostream &out, const LaneDataVector &turn_la
 
     return out;
 }
-} // namespace lanes
-} // namespace guidance
+}
+}
 
 namespace extractor
 {
@@ -204,8 +204,7 @@ inline std::ostream &operator<<(std::ostream &out, const EdgeBasedEdge &edge)
     out << "}";
     return out;
 }
-
-} // namespace extractor
-} // namespace osrm
+}
+}
 
 #endif /*OSRM_ENGINE_GUIDANCE_DEBUG_HPP_*/

include/util/ieee754.hpp

@@ -29,7 +29,7 @@ THE SOFTWARE.
 #include <math.h>
 
 #if defined(_MSC_VER)
-#include "msinttypes/stdint.h"
+#include "rapidjson/msinttypes/stdint.h"
 #include <intrin.h>
 #else
 #include <stdint.h>

include/util/node_based_graph.hpp

@@ -88,12 +88,8 @@ NodeBasedDynamicGraphFromEdges(NodeID number_of_nodes,
             output_edge.data.flags = input_edge.flags;
             output_edge.data.annotation_data = input_edge.annotation_data;
 
-            BOOST_ASSERT(output_edge.data.weight >= 0);
-            BOOST_ASSERT(output_edge.data.duration >= 0);
-            if (output_edge.data.distance <= 0)
-            {
-                std::cout << "output_edge.data.distance " << output_edge.data.distance << std::endl;
-            }
+            BOOST_ASSERT(output_edge.data.weight > 0);
+            BOOST_ASSERT(output_edge.data.duration > 0);
             BOOST_ASSERT(output_edge.data.distance >= 0);
         });
 
@@ -101,7 +97,7 @@ NodeBasedDynamicGraphFromEdges(NodeID number_of_nodes,
 
     return NodeBasedDynamicGraph(number_of_nodes, edges_list);
 }
-} // namespace util
-} // namespace osrm
+}
+}
 
 #endif // NODE_BASED_GRAPH_HPP

include/util/typedefs.hpp

@@ -48,7 +48,7 @@ struct osm_way_id
 struct duplicated_node
 {
 };
-} // namespace tag
+}
 using OSMNodeID = osrm::Alias<std::uint64_t, tag::osm_node_id>;
 static_assert(std::is_pod<OSMNodeID>(), "OSMNodeID is not a valid alias");
 using OSMWayID = osrm::Alias<std::uint64_t, tag::osm_way_id>;

include/util/vector_view.hpp

@@ -198,6 +198,7 @@ template <> class vector_view<bool>
         // Note: ordering of bits here should match packBits in storage/serialization.hpp
         //       so that directly mmap-ing data is possible
         const auto offset = index % WORD_BITS;
+        BOOST_ASSERT(WORD_BITS > offset);
         return m_ptr[bucket] & (static_cast<Word>(1) << offset);
     }
 
@@ -229,6 +230,7 @@ template <> class vector_view<bool>
         // Note: ordering of bits here should match packBits in storage/serialization.hpp
         //       so that directly mmap-ing data is possible
         const auto offset = index % WORD_BITS;
+        BOOST_ASSERT(WORD_BITS > offset);
         return reference{m_ptr + bucket, static_cast<Word>(1) << offset};
     }
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "osrm",
-  "version": "5.20.0-alpha.3",
+  "version": "5.20.0-rc.2",
   "private": false,
   "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
   "dependencies": {

profiles/car.lua

@@ -120,6 +120,9 @@ function setup()
 
     -- classes to support for exclude flags
     excludable = Sequence {
+        Set {'toll'},
+        Set {'motorway'},
+        Set {'ferry'}
     },
 
     avoid = Set {

scripts/timer.js

@@ -6,8 +6,12 @@ var fs = require('fs');
 var name = process.argv[2];
 var cmd = process.argv.slice(3).join(' ');
 var start = Date.now();
-exec(cmd, (err) => {
-    if (err) return console.log(err);
+exec(cmd, (err, stdout, stderr) => {
+    if (err) {
+        console.log(stdout);
+        console.log(stderr);
+        return process.exit(err.code);
+    }
     var stop = +new Date();
     var time = (stop - start) / 1000.;
     fs.appendFileSync('/tmp/osrm.timings', `${name}\t${time}`, 'utf-8');

src/contractor/contractor.cpp

@@ -102,7 +102,6 @@ int Contractor::Run()
     QueryGraph query_graph;
     std::vector<std::vector<bool>> edge_filters;
     std::vector<std::vector<bool>> cores;
-
     std::tie(query_graph, edge_filters) = contractExcludableGraph(
         toContractorGraph(number_of_edge_based_nodes, std::move(edge_based_edge_list)),
         std::move(node_weights),

src/contractor/graph_contractor.cpp

@@ -560,7 +560,7 @@ bool IsNodeIndependent(const util::XORFastHash<> &hash,
     }
     return true;
 }
-} // namespace
+}
 
 std::vector<bool> contractGraph(ContractorGraph &graph,
                                 std::vector<bool> node_is_uncontracted_,

src/customize/customizer.cpp

@@ -76,6 +76,7 @@ auto LoadAndUpdateEdgeExpandedGraph(const CustomizationConfig &config,
                                     const partitioner::MultiLevelPartition &mlp,
                                     std::vector<EdgeWeight> &node_weights,
                                     std::vector<EdgeDuration> &node_durations,
+                                    std::vector<EdgeDistance> &node_distances,
                                     std::uint32_t &connectivity_checksum)
 {
     updater::Updater updater(config.updater_config);
@@ -84,6 +85,8 @@ auto LoadAndUpdateEdgeExpandedGraph(const CustomizationConfig &config,
     EdgeID num_nodes = updater.LoadAndUpdateEdgeExpandedGraph(
         edge_based_edge_list, node_weights, node_durations, connectivity_checksum);
 
+    extractor::files::readEdgeBasedNodeDistances(config.GetPath(".osrm.enw"), node_distances);
+
     auto directed = partitioner::splitBidirectionalEdges(edge_based_edge_list);
 
     auto tidied = partitioner::prepareEdgesForUsageInGraph<
@@ -124,10 +127,11 @@ int Customizer::Run(const CustomizationConfig &config)
     partitioner::files::readPartition(config.GetPath(".osrm.partition"), mlp);
 
     std::vector<EdgeWeight> node_weights;
-    std::vector<EdgeDuration> node_durations; // TODO: to be removed later
+    std::vector<EdgeDuration> node_durations; // TODO: remove when durations are optional
+    std::vector<EdgeDistance> node_distances; // TODO: remove when distances are optional
     std::uint32_t connectivity_checksum = 0;
     auto graph = LoadAndUpdateEdgeExpandedGraph(
-        config, mlp, node_weights, node_durations, connectivity_checksum);
+        config, mlp, node_weights, node_durations, node_distances, connectivity_checksum);
     BOOST_ASSERT(graph.GetNumberOfNodes() == node_weights.size());
     std::for_each(node_weights.begin(), node_weights.end(), [](auto &w) { w &= 0x7fffffff; });
     util::Log() << "Loaded edge based graph: " << graph.GetNumberOfEdges() << " edges, "
@@ -166,8 +170,10 @@ int Customizer::Run(const CustomizationConfig &config)
     util::Log() << "MLD customization writing took " << TIMER_SEC(writing_mld_data) << " seconds";
 
     TIMER_START(writing_graph);
-    MultiLevelEdgeBasedGraph shaved_graph{
-        std::move(graph), std::move(node_weights), std::move(node_durations)};
+    MultiLevelEdgeBasedGraph shaved_graph{std::move(graph),
+                                          std::move(node_weights),
+                                          std::move(node_durations),
+                                          std::move(node_distances)};
     customizer::files::writeGraph(
         config.GetPath(".osrm.mldgr"), shaved_graph, connectivity_checksum);
     TIMER_STOP(writing_graph);

src/engine/datafacade/mmap_memory_allocator.cpp

@@ -8,7 +8,7 @@
 #include "util/log.hpp"
 #include "util/mmap_file.hpp"
 
-#include "boost/assert.hpp"
+#include <boost/assert.hpp>
 
 namespace osrm
 {
@@ -28,7 +28,7 @@ MMapMemoryAllocator::MMapMemoryAllocator(const storage::StorageConfig &config)
 
         // Convert the boost::filesystem::path object into a plain string
         // that's stored as a member of this allocator object
-        rtree_filename = storage.PopulateLayoutWithRTree(fake_layout);
+        rtree_filename = storage.PopulateLayoutWithRTree(*fake_layout);
 
         // Now, we add one more AllocatedRegion, with it's start address as the start
         // of the rtree_filename string we've saved.  In the fake_layout, we've
@@ -42,9 +42,8 @@ MMapMemoryAllocator::MMapMemoryAllocator(const storage::StorageConfig &config)
         allocated_regions.push_back({&(rtree_filename[0]), std::move(fake_layout)});
     }
 
-    std::vector<std::pair<bool, boost::filesystem::path>> files = storage.GetStaticFiles();
-    std::vector<std::pair<bool, boost::filesystem::path>> updatable_files =
-        storage.GetUpdatableFiles();
+    auto files = storage.GetStaticFiles();
+    auto updatable_files = storage.GetUpdatableFiles();
     files.insert(files.end(), updatable_files.begin(), updatable_files.end());
 
     for (const auto &file : files)
@@ -56,13 +55,13 @@ MMapMemoryAllocator::MMapMemoryAllocator(const storage::StorageConfig &config)
             boost::iostreams::mapped_file mapped_memory_file;
             util::mmapFile<char>(file.second, mapped_memory_file);
             mapped_memory_files.push_back(std::move(mapped_memory_file));
-            storage.readBlocks(file.second, layout);
+            storage::populateLayoutFromFile(file.second, *layout);
             allocated_regions.push_back({mapped_memory_file.data(), std::move(layout)});
         }
     }
 
     index = storage::SharedDataIndex{std::move(allocated_regions)};
-} // namespace datafacade
+}
 
 MMapMemoryAllocator::~MMapMemoryAllocator() {}
 

src/engine/datafacade/process_memory_allocator.cpp

@@ -15,13 +15,13 @@ ProcessMemoryAllocator::ProcessMemoryAllocator(const storage::StorageConfig &con
     storage::Storage storage(config);
 
     // Calculate the layout/size of the memory block
-    std::vector<std::pair<bool, boost::filesystem::path>> static_files = storage.GetStaticFiles();
-    std::vector<std::pair<bool, boost::filesystem::path>> updatable_files =
-        storage.GetUpdatableFiles();
-    std::unique_ptr<storage::BaseDataLayout> layout = std::make_unique<storage::DataLayout>();
-    storage.PopulateLayoutWithRTree(layout);
-    storage.PopulateLayout(layout, static_files);
-    storage.PopulateLayout(layout, updatable_files);
+    auto static_files = storage.GetStaticFiles();
+    auto updatable_files = storage.GetUpdatableFiles();
+    std::unique_ptr<storage::BaseDataLayout> layout =
+        std::make_unique<storage::ContiguousDataLayout>();
+    storage.PopulateLayoutWithRTree(*layout);
+    storage.PopulateLayout(*layout, static_files);
+    storage.PopulateLayout(*layout, updatable_files);
 
     // Allocate the memory block, then load data from files into it
     internal_memory = std::make_unique<char[]>(layout->GetSizeOfLayout());
@@ -34,7 +34,7 @@ ProcessMemoryAllocator::ProcessMemoryAllocator(const storage::StorageConfig &con
     storage.PopulateUpdatableData(index);
 }
 
-ProcessMemoryAllocator::~ProcessMemoryAllocator() { /* free(internal_memory) */}
+ProcessMemoryAllocator::~ProcessMemoryAllocator() {}
 
 const storage::SharedDataIndex &ProcessMemoryAllocator::GetIndex() { return index; }
 

src/engine/datafacade/shared_memory_allocator.cpp

@@ -25,8 +25,9 @@ SharedMemoryAllocator::SharedMemoryAllocator(
         auto mem = storage::makeSharedMemory(shm_key);
 
         storage::io::BufferReader reader(reinterpret_cast<char *>(mem->Ptr()), mem->Size());
-        std::unique_ptr<storage::BaseDataLayout> layout = std::make_unique<storage::DataLayout>();
-        storage::serialization::read(reader, layout);
+        std::unique_ptr<storage::BaseDataLayout> layout =
+            std::make_unique<storage::ContiguousDataLayout>();
+        storage::serialization::read(reader, *layout);
         auto layout_size = reader.GetPosition();
 
         regions.push_back({reinterpret_cast<char *>(mem->Ptr()) + layout_size, std::move(layout)});

src/engine/engine_config.cpp

@@ -27,5 +27,5 @@ bool EngineConfig::IsValid() const
             storage_config.IsValid()) &&
            limits_valid;
 }
-} // namespace engine
-} // namespace osrm
+}
+}

src/engine/plugins/table.cpp

@@ -4,6 +4,7 @@
 #include "engine/api/table_parameters.hpp"
 #include "engine/routing_algorithms/many_to_many.hpp"
 #include "engine/search_engine_data.hpp"
+#include "util/coordinate_calculation.hpp"
 #include "util/json_container.hpp"
 #include "util/string_util.hpp"
 
@@ -86,7 +87,7 @@ Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
     bool request_duration = params.annotations & api::TableParameters::AnnotationsType::Duration;
 
     auto result_tables_pair = algorithms.ManyToManySearch(
-        snapped_phantoms, params.sources, params.destinations, request_distance, request_duration);
+        snapped_phantoms, params.sources, params.destinations, request_distance);
 
     if ((request_duration && result_tables_pair.first.empty()) ||
         (request_distance && result_tables_pair.second.empty()))
@@ -94,6 +95,33 @@ Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
         return Error("NoTable", "No table found", result);
     }
 
+    // Scan table for null results - if any exist, replace with distance estimates
+    if (params.noroute_estimate > 0)
+    {
+        for (std::size_t row = 0; row < num_sources; row++)
+        {
+            for (std::size_t column = 0; column < num_destinations; column++)
+            {
+                if (result_tables_pair.first[row * num_sources + column] == MAXIMAL_EDGE_DURATION)
+                {
+                    auto distance_estimate = util::coordinate_calculation::fccApproximateDistance(
+                        snapped_phantoms[params.sources.empty() ? row : params.sources[row]]
+                            .location,
+                        snapped_phantoms[params.destinations.empty() ? column
+                                                                     : params.destinations[column]]
+                            .location);
+
+                    result_tables_pair.first[row * num_sources + column] =
+                        distance_estimate / (double)params.noroute_estimate;
+                    if (!result_tables_pair.second.empty())
+                    {
+                        result_tables_pair.second[row * num_sources + column] = distance_estimate;
+                    }
+                }
+            }
+        }
+    }
+
     api::TableAPI table_api{facade, params};
     table_api.MakeResponse(result_tables_pair, snapped_phantoms, result);
 

src/engine/plugins/trip.cpp

@@ -217,10 +217,7 @@ Status TripPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
 
     // compute the duration table of all phantom nodes
     auto result_duration_table = util::DistTableWrapper<EdgeWeight>(
-        algorithms
-            .ManyToManySearch(
-                snapped_phantoms, {}, {}, /*requestDistance*/ false, /*requestDuration*/ true)
-            .first,
+        algorithms.ManyToManySearch(snapped_phantoms, {}, {}, /*requestDistance*/ false).first,
         number_of_locations);
 
     if (result_duration_table.size() == 0)

src/engine/routing_algorithms/alternative_path_ch.cpp

@@ -558,7 +558,7 @@ bool viaNodeCandidatePassesTTest(SearchEngineData<Algorithm> &engine_working_dat
     }
     return (upper_bound <= t_test_path_weight);
 }
-} // namespace
+} // anon. namespace
 
 InternalManyRoutesResult alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
                                                const DataFacade<Algorithm> &facade,
@@ -853,4 +853,4 @@ InternalManyRoutesResult alternativePathSearch(SearchEngineData<Algorithm> &engi
 
 } // namespace routing_algorithms
 } // namespace engine
-} // namespace osrm
+} // namespace osrm}

src/engine/routing_algorithms/many_to_many_ch.cpp

@@ -120,8 +120,13 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
         const auto target_distance = current_bucket.distance;
 
         auto &current_weight = weights_table[row_index * number_of_targets + column_index];
+
+        EdgeDistance nulldistance = 0;
+
         auto &current_duration = durations_table[row_index * number_of_targets + column_index];
-        auto &current_distance = distances_table[row_index * number_of_targets + column_index];
+        auto &current_distance =
+            distances_table.empty() ? nulldistance
+                                    : distances_table[row_index * number_of_targets + column_index];
 
         // Check if new weight is better
         auto new_weight = source_weight + target_weight;
@@ -173,160 +178,6 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
 
 } // namespace ch
 
-void retrievePackedPathFromSearchSpace(const NodeID middle_node_id,
-                                       const unsigned column_index,
-                                       const std::vector<NodeBucket> &search_space_with_buckets,
-                                       std::vector<NodeID> &packed_leg)
-{
-    auto bucket_list = std::equal_range(search_space_with_buckets.begin(),
-                                        search_space_with_buckets.end(),
-                                        middle_node_id,
-                                        NodeBucket::ColumnCompare(column_index));
-
-    NodeID current_node_id = middle_node_id;
-
-    BOOST_ASSERT_MSG(std::distance(bucket_list.first, bucket_list.second) == 1,
-                     "The pointers are not pointing to the same element.");
-
-    while (bucket_list.first->parent_node != current_node_id &&
-           bucket_list.first != search_space_with_buckets.end())
-    {
-        current_node_id = bucket_list.first->parent_node;
-
-        packed_leg.emplace_back(current_node_id);
-
-        bucket_list = std::equal_range(search_space_with_buckets.begin(),
-                                       search_space_with_buckets.end(),
-                                       current_node_id,
-                                       NodeBucket::ColumnCompare(column_index));
-    }
-}
-
-void calculateDistances(typename SearchEngineData<ch::Algorithm>::ManyToManyQueryHeap &query_heap,
-                        const DataFacade<ch::Algorithm> &facade,
-                        const std::vector<PhantomNode> &phantom_nodes,
-                        const std::vector<std::size_t> &target_indices,
-                        const std::size_t row_index,
-                        const std::size_t source_index,
-                        const PhantomNode &source_phantom,
-                        const std::size_t number_of_targets,
-                        const std::vector<NodeBucket> &search_space_with_buckets,
-                        std::vector<EdgeDistance> &distances_table,
-                        const std::vector<NodeID> &middle_nodes_table)
-{
-    std::vector<NodeID> packed_leg;
-
-    for (auto column_index : util::irange<std::size_t>(0, number_of_targets))
-    {
-        const auto target_index = target_indices[column_index];
-        const auto &target_phantom = phantom_nodes[target_index];
-
-        if (source_index == target_index)
-        {
-            distances_table[row_index * number_of_targets + column_index] = 0.0;
-            continue;
-        }
-
-        NodeID middle_node_id = middle_nodes_table[row_index * number_of_targets + column_index];
-
-        if (middle_node_id == SPECIAL_NODEID) // takes care of one-ways
-        {
-            distances_table[row_index * number_of_targets + column_index] = INVALID_EDGE_DISTANCE;
-            continue;
-        }
-
-        // Step 1: Find path from source to middle node
-        ch::retrievePackedPathFromSingleManyToManyHeap(query_heap, middle_node_id, packed_leg);
-        std::reverse(packed_leg.begin(), packed_leg.end());
-
-        packed_leg.push_back(middle_node_id);
-
-        // Step 2: Find path from middle to target node
-        retrievePackedPathFromSearchSpace(
-            middle_node_id, column_index, search_space_with_buckets, packed_leg);
-
-        if (packed_leg.size() == 1 && (needsLoopForward(source_phantom, target_phantom) ||
-                                       needsLoopBackwards(source_phantom, target_phantom)))
-        {
-            auto weight = ch::getLoopWeight<false>(facade, packed_leg.front());
-            if (std::get<0>(weight) != INVALID_EDGE_WEIGHT)
-                packed_leg.push_back(packed_leg.front());
-        }
-        if (!packed_leg.empty())
-        {
-            auto annotation =
-                ch::calculateEBGNodeAnnotations(facade, packed_leg.begin(), packed_leg.end());
-
-            distances_table[row_index * number_of_targets + column_index] = annotation;
-
-            // check the direction of travel to figure out how to calculate the offset to/from
-            // the source/target
-            if (source_phantom.forward_segment_id.id == packed_leg.front())
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
-                //       -->s               <-- subtract offset to start at source
-                //          .........       <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                EdgeDistance offset = source_phantom.GetForwardDistance();
-                distances_table[row_index * number_of_targets + column_index] -= offset;
-            }
-            else if (source_phantom.reverse_segment_id.id == packed_leg.front())
-            {
-                //       ............    <-- calculateEGBAnnotation returns distance from 0 to 3
-                //          s<-------    <-- subtract offset to start at source
-                //       ...             <-- want this distance
-                // entry 0---1---2---3   <-- 3 is exit node
-                EdgeDistance offset = source_phantom.GetReverseDistance();
-                distances_table[row_index * number_of_targets + column_index] -= offset;
-            }
-            if (target_phantom.forward_segment_id.id == packed_leg.back())
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
-                //                   ++>t   <-- add offset to get to target
-                //       ................   <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                EdgeDistance offset = target_phantom.GetForwardDistance();
-                distances_table[row_index * number_of_targets + column_index] += offset;
-            }
-            else if (target_phantom.reverse_segment_id.id == packed_leg.back())
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
-                //                   <++t   <-- add offset to get from target
-                //       ................   <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                EdgeDistance offset = target_phantom.GetReverseDistance();
-                distances_table[row_index * number_of_targets + column_index] += offset;
-            }
-        }
-        else
-        {
-            // there is no shortcut to unpack. source and target are on the same EBG Node.
-            // if the offset of the target is greater than the offset of the source, subtract it
-            if (target_phantom.GetForwardDistance() > source_phantom.GetForwardDistance())
-            {
-                //       --------->t        <-- offsets
-                //       ->s                <-- subtract source offset from target offset
-                //         .........        <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                EdgeDistance offset =
-                    target_phantom.GetForwardDistance() - source_phantom.GetForwardDistance();
-                distances_table[row_index * number_of_targets + column_index] = offset;
-            }
-            else
-            {
-                //               s<---      <-- offsets
-                //         t<---------      <-- subtract source offset from target offset
-                //         ......           <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                EdgeDistance offset =
-                    target_phantom.GetReverseDistance() - source_phantom.GetReverseDistance();
-                distances_table[row_index * number_of_targets + column_index] = offset;
-            }
-        }
-        packed_leg.clear();
-    }
-}
-
 template <>
 std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
 manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
@@ -334,18 +185,16 @@ manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
                  const std::vector<PhantomNode> &phantom_nodes,
                  const std::vector<std::size_t> &source_indices,
                  const std::vector<std::size_t> &target_indices,
-                 const bool calculate_distance,
-                 const bool calculate_duration)
+                 const bool calculate_distance)
 {
-    (void)calculate_duration; // TODO: stub to use when computing durations become optional
-
     const auto number_of_sources = source_indices.size();
     const auto number_of_targets = target_indices.size();
     const auto number_of_entries = number_of_sources * number_of_targets;
 
     std::vector<EdgeWeight> weights_table(number_of_entries, INVALID_EDGE_WEIGHT);
     std::vector<EdgeDuration> durations_table(number_of_entries, MAXIMAL_EDGE_DURATION);
-    std::vector<EdgeDistance> distances_table(number_of_entries, MAXIMAL_EDGE_DISTANCE);
+    std::vector<EdgeDistance> distances_table(calculate_distance ? number_of_entries : 0,
+                                              MAXIMAL_EDGE_DISTANCE);
     std::vector<NodeID> middle_nodes_table(number_of_entries, SPECIAL_NODEID);
 
     std::vector<NodeBucket> search_space_with_buckets;
@@ -398,26 +247,6 @@ manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
                                middle_nodes_table,
                                source_phantom);
         }
-
-        if (calculate_distance)
-        {
-            distances_table.resize(number_of_entries, INVALID_EDGE_DISTANCE);
-            // TODO: this is a hack to work around stuff
-            if (number_of_entries == 0)
-            {
-                calculateDistances(query_heap,
-                                   facade,
-                                   phantom_nodes,
-                                   target_indices,
-                                   row_index,
-                                   source_index,
-                                   source_phantom,
-                                   number_of_targets,
-                                   search_space_with_buckets,
-                                   distances_table,
-                                   middle_nodes_table);
-            }
-        }
     }
 
     return std::make_pair(durations_table, distances_table);

src/engine/routing_algorithms/many_to_many_mld.cpp

@@ -41,7 +41,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         const EdgeDuration duration,
-                        const EdgeDistance /* distance TODO use this */,
+                        const EdgeDistance distance,
                         typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
                         Args... args)
 {
@@ -66,65 +66,77 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
         { // Shortcuts in forward direction
             auto destination = cell.GetDestinationNodes().begin();
             auto shortcut_durations = cell.GetOutDuration(node);
+            auto shortcut_distances = cell.GetOutDistance(node);
             for (auto shortcut_weight : cell.GetOutWeight(node))
             {
                 BOOST_ASSERT(destination != cell.GetDestinationNodes().end());
                 BOOST_ASSERT(!shortcut_durations.empty());
+                BOOST_ASSERT(!shortcut_distances.empty());
                 const NodeID to = *destination;
 
                 if (shortcut_weight != INVALID_EDGE_WEIGHT && node != to)
                 {
                     const auto to_weight = weight + shortcut_weight;
                     const auto to_duration = duration + shortcut_durations.front();
+                    const auto to_distance = distance + shortcut_distances.front();
                     if (!query_heap.WasInserted(to))
                     {
-                        query_heap.Insert(to, to_weight, {node, true, to_duration, 0});
+                        query_heap.Insert(to, to_weight, {node, true, to_duration, to_distance});
                     }
-                    else if (std::tie(to_weight, to_duration, node) <
+                    else if (std::tie(to_weight, to_duration, to_distance, node) <
                              std::tie(query_heap.GetKey(to),
                                       query_heap.GetData(to).duration,
+                                      query_heap.GetData(to).distance,
                                       query_heap.GetData(to).parent))
                     {
-                        query_heap.GetData(to) = {node, true, to_duration, 0};
+                        query_heap.GetData(to) = {node, true, to_duration, to_distance};
                         query_heap.DecreaseKey(to, to_weight);
                     }
                 }
                 ++destination;
                 shortcut_durations.advance_begin(1);
+                shortcut_distances.advance_begin(1);
             }
             BOOST_ASSERT(shortcut_durations.empty());
+            BOOST_ASSERT(shortcut_distances.empty());
         }
         else
         { // Shortcuts in backward direction
             auto source = cell.GetSourceNodes().begin();
             auto shortcut_durations = cell.GetInDuration(node);
+            auto shortcut_distances = cell.GetInDistance(node);
             for (auto shortcut_weight : cell.GetInWeight(node))
             {
                 BOOST_ASSERT(source != cell.GetSourceNodes().end());
                 BOOST_ASSERT(!shortcut_durations.empty());
+                BOOST_ASSERT(!shortcut_distances.empty());
                 const NodeID to = *source;
 
                 if (shortcut_weight != INVALID_EDGE_WEIGHT && node != to)
                 {
                     const auto to_weight = weight + shortcut_weight;
                     const auto to_duration = duration + shortcut_durations.front();
+                    const auto to_distance = distance + shortcut_distances.front();
                     if (!query_heap.WasInserted(to))
                     {
-                        query_heap.Insert(to, to_weight, {node, true, to_duration, 0});
+                        query_heap.Insert(to, to_weight, {node, true, to_duration, to_distance});
                     }
-                    else if (std::tie(to_weight, to_duration, node) <
+                    else if (std::tie(to_weight, to_duration, to_distance, node) <
                              std::tie(query_heap.GetKey(to),
                                       query_heap.GetData(to).duration,
+                                      query_heap.GetData(to).distance,
                                       query_heap.GetData(to).parent))
                     {
-                        query_heap.GetData(to) = {node, true, to_duration, 0};
+                        query_heap.GetData(to) = {node, true, to_duration, to_distance};
                         query_heap.DecreaseKey(to, to_weight);
                     }
                 }
                 ++source;
                 shortcut_durations.advance_begin(1);
+                shortcut_distances.advance_begin(1);
             }
             BOOST_ASSERT(shortcut_durations.empty());
+            BOOST_ASSERT(shortcut_distances.empty());
         }
     }
 
@@ -144,25 +156,28 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
             const auto node_id = DIRECTION == FORWARD_DIRECTION ? node : facade.GetTarget(edge);
             const auto node_weight = facade.GetNodeWeight(node_id);
             const auto node_duration = facade.GetNodeDuration(node_id);
+            const auto node_distance = facade.GetNodeDistance(node_id);
             const auto turn_weight = node_weight + facade.GetWeightPenaltyForEdgeID(turn_id);
             const auto turn_duration = node_duration + facade.GetDurationPenaltyForEdgeID(turn_id);
 
             BOOST_ASSERT_MSG(node_weight + turn_weight > 0, "edge weight is invalid");
             const auto to_weight = weight + turn_weight;
             const auto to_duration = duration + turn_duration;
+            const auto to_distance = distance + node_distance;
 
             // New Node discovered -> Add to Heap + Node Info Storage
             if (!query_heap.WasInserted(to))
             {
-                query_heap.Insert(to, to_weight, {node, false, to_duration, 0});
+                query_heap.Insert(to, to_weight, {node, false, to_duration, to_distance});
             }
             // Found a shorter Path -> Update weight and set new parent
-            else if (std::tie(to_weight, to_duration, node) <
+            else if (std::tie(to_weight, to_duration, to_distance, node) <
                      std::tie(query_heap.GetKey(to),
                               query_heap.GetData(to).duration,
+                              query_heap.GetData(to).distance,
                               query_heap.GetData(to).parent))
             {
-                query_heap.GetData(to) = {node, false, to_duration, 0};
+                query_heap.GetData(to) = {node, false, to_duration, to_distance};
                 query_heap.DecreaseKey(to, to_weight);
             }
         }
@@ -179,11 +194,12 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                 const std::vector<PhantomNode> &phantom_nodes,
                 std::size_t phantom_index,
                 const std::vector<std::size_t> &phantom_indices,
-                const bool /* calculate_distance */)
+                const bool calculate_distance)
 {
     std::vector<EdgeWeight> weights(phantom_indices.size(), INVALID_EDGE_WEIGHT);
     std::vector<EdgeDuration> durations(phantom_indices.size(), MAXIMAL_EDGE_DURATION);
-    std::vector<EdgeDistance> distances_table(phantom_indices.size(), MAXIMAL_EDGE_DISTANCE);
+    std::vector<EdgeDistance> distances_table(calculate_distance ? phantom_indices.size() : 0,
+                                              MAXIMAL_EDGE_DISTANCE);
     std::vector<NodeID> middle_nodes_table(phantom_indices.size(), SPECIAL_NODEID);
 
     // Collect destination (source) nodes into a map
@@ -245,7 +261,7 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                 std::size_t index;
                 EdgeWeight target_weight;
                 EdgeDuration target_duration;
-                EdgeDuration target_distance;
+                EdgeDistance target_distance;
                 std::tie(index, target_weight, target_duration, target_distance) = it->second;
 
                 const auto path_weight = weight + target_weight;
@@ -254,12 +270,16 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                     const auto path_duration = duration + target_duration;
                     const auto path_distance = distance + target_distance;
 
-                    if (std::tie(path_weight, path_duration) <
-                        std::tie(weights[index], durations[index]))
+                    EdgeDistance nulldistance = 0;
+                    auto &current_distance =
+                        distances_table.empty() ? nulldistance : distances_table[index];
+
+                    if (std::tie(path_weight, path_duration, path_distance) <
+                        std::tie(weights[index], durations[index], current_distance))
                     {
                         weights[index] = path_weight;
                         durations[index] = path_duration;
-                        distances_table[index] = path_distance;
+                        current_distance = path_distance;
                         middle_nodes_table[index] = node;
                     }
 
@@ -277,6 +297,7 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                            EdgeWeight initial_weight,
                            EdgeDuration initial_duration,
                            EdgeDistance initial_distance) {
+
         // Update single node paths
         update_values(node, initial_weight, initial_duration, initial_distance);
 
@@ -303,7 +324,7 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                                          facade.GetWeightPenaltyForEdgeID(turn_id);
                 const auto edge_duration = initial_duration + facade.GetNodeDuration(node_id) +
                                            facade.GetDurationPenaltyForEdgeID(turn_id);
-                const auto edge_distance = initial_distance;
+                const auto edge_distance = initial_distance + facade.GetNodeDistance(node_id);
 
                 query_heap.Insert(to, edge_weight, {node, edge_duration, edge_distance});
             }
@@ -374,128 +395,6 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                                       phantom_indices);
     }
 
-    // TODO: re-enable this if we need to fallback
-    // if (calculate_distance)
-    if (false)
-    {
-        // Initialize unpacking heaps
-        engine_working_data.InitializeOrClearFirstThreadLocalStorage(
-            facade.GetNumberOfNodes(), facade.GetMaxBorderNodeID() + 1);
-
-        distances_table.resize(phantom_indices.size(), INVALID_EDGE_DISTANCE);
-
-        for (unsigned location = 0; location < phantom_indices.size(); ++location)
-        {
-            // Get the "middle" node that is the last node of a path
-            const NodeID middle_node_id = middle_nodes_table[location];
-            if (middle_node_id == SPECIAL_NODEID) // takes care of one-ways
-            {
-                continue;
-            }
-
-            // Retrieve the packed path from the heap
-            PackedPath packed_path = mld::retrievePackedPathFromSingleManyToManyHeap<DIRECTION>(
-                query_heap, middle_node_id);
-
-            // ... and reverse it to have packed edges in the correct order,
-            if (DIRECTION == FORWARD_DIRECTION)
-            {
-                std::reverse(packed_path.begin(), packed_path.end());
-            }
-
-            // ... unpack path
-            auto &forward_heap = *engine_working_data.forward_heap_1;
-            auto &reverse_heap = *engine_working_data.reverse_heap_1;
-            EdgeWeight weight = INVALID_EDGE_WEIGHT;
-            std::vector<NodeID> unpacked_nodes;
-            std::vector<EdgeID> unpacked_edges;
-
-            std::tie(weight, unpacked_nodes, unpacked_edges) =
-                unpackPathAndCalculateDistance(engine_working_data,
-                                               facade,
-                                               forward_heap,
-                                               reverse_heap,
-                                               DO_NOT_FORCE_LOOPS,
-                                               DO_NOT_FORCE_LOOPS,
-                                               INVALID_EDGE_WEIGHT,
-                                               packed_path,
-                                               middle_node_id,
-                                               phantom_nodes,
-                                               phantom_index,
-                                               phantom_indices);
-
-            // Accumulate the path length without the last node
-            auto annotation = 0.0;
-
-            BOOST_ASSERT(!unpacked_nodes.empty());
-            for (auto node = unpacked_nodes.begin(), last_node = std::prev(unpacked_nodes.end());
-                 node != last_node;
-                 ++node)
-            {
-                annotation += computeEdgeDistance(facade, *node);
-            }
-
-            // ... and add negative source and positive target offsets
-            // ⚠ for REVERSE_DIRECTION original source and target phantom nodes are swapped
-            // Get source and target phantom nodes
-            // * 1-to-N: source is a single index, target is the corresponding from the indices list
-            // * N-to-1: source is the corresponding from the indices list, target is a single index
-            auto source_phantom_index = phantom_index;
-            auto target_phantom_index = phantom_indices[location];
-            if (DIRECTION == REVERSE_DIRECTION)
-            {
-                std::swap(source_phantom_index, target_phantom_index);
-            }
-            const auto &source_phantom = phantom_nodes[source_phantom_index];
-            const auto &target_phantom = phantom_nodes[target_phantom_index];
-            const NodeID source_node = unpacked_nodes.front();
-            const NodeID target_node = unpacked_nodes.back();
-
-            EdgeDistance source_offset = 0., target_offset = 0.;
-            if (source_phantom.IsValidForwardSource() &&
-                source_phantom.forward_segment_id.id == source_node)
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0
-                //       to 3
-                //       -->s               <-- subtract offset to start at source
-                //          .........       <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                source_offset = source_phantom.GetForwardDistance();
-            }
-            else if (source_phantom.IsValidReverseSource() &&
-                     source_phantom.reverse_segment_id.id == source_node)
-            {
-                //       ............    <-- calculateEGBAnnotation returns distance from 0 to 3
-                //          s<-------    <-- subtract offset to start at source
-                //       ...             <-- want this distance
-                // entry 0---1---2---3   <-- 3 is exit node
-                source_offset = source_phantom.GetReverseDistance();
-            }
-            if (target_phantom.IsValidForwardTarget() &&
-                target_phantom.forward_segment_id.id == target_node)
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0
-                //       to 3
-                //                   ++>t   <-- add offset to get to target
-                //       ................   <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                target_offset = target_phantom.GetForwardDistance();
-            }
-            else if (target_phantom.IsValidReverseTarget() &&
-                     target_phantom.reverse_segment_id.id == target_node)
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0
-                //       to 3
-                //                   <++t   <-- add offset to get from target
-                //       ................   <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                target_offset = target_phantom.GetReverseDistance();
-            }
-
-            distances_table[location] = -source_offset + annotation + target_offset;
-        }
-    }
-
     return std::make_pair(durations, distances_table);
 }
 
@@ -511,6 +410,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                         const std::vector<NodeBucket> &search_space_with_buckets,
                         std::vector<EdgeWeight> &weights_table,
                         std::vector<EdgeDuration> &durations_table,
+                        std::vector<EdgeDistance> &distances_table,
                         std::vector<NodeID> &middle_nodes_table,
                         const PhantomNode &phantom_node)
 {
@@ -530,6 +430,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
         const auto column_idx = current_bucket.column_index;
         const auto target_weight = current_bucket.weight;
         const auto target_duration = current_bucket.duration;
+        const auto target_distance = current_bucket.distance;
 
         // Get the value location in the results tables:
         //  * row-major direct (row_idx, column_idx) index for forward direction
@@ -540,15 +441,21 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
         auto &current_weight = weights_table[location];
         auto &current_duration = durations_table[location];
 
+        EdgeDistance nulldistance = 0;
+        auto &current_distance = distances_table.empty() ? nulldistance : distances_table[location];
+
         // Check if new weight is better
         auto new_weight = source_weight + target_weight;
         auto new_duration = source_duration + target_duration;
+        auto new_distance = source_distance + target_distance;
 
         if (new_weight >= 0 &&
-            std::tie(new_weight, new_duration) < std::tie(current_weight, current_duration))
+            std::tie(new_weight, new_duration, new_distance) <
+                std::tie(current_weight, current_duration, current_distance))
         {
             current_weight = new_weight;
             current_duration = new_duration;
+            current_distance = new_distance;
             middle_nodes_table[location] = node;
         }
     }
@@ -573,7 +480,7 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
 
     // Store settled nodes in search space bucket
     search_space_with_buckets.emplace_back(
-        node, parent, from_clique_arc, column_idx, target_weight, target_duration);
+        node, parent, from_clique_arc, column_idx, target_weight, target_duration, target_distance);
 
     const auto &partition = facade.GetMultiLevelPartition();
     const auto maximal_level = partition.GetNumberOfLevels() - 1;
@@ -624,182 +531,6 @@ void retrievePackedPathFromSearchSpace(NodeID middle_node_id,
     }
 }
 
-template <bool DIRECTION>
-void calculateDistances(typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
-                        const DataFacade<mld::Algorithm> &facade,
-                        const std::vector<PhantomNode> &phantom_nodes,
-                        const std::vector<std::size_t> &target_indices,
-                        const unsigned row_idx,
-                        const std::size_t source_index,
-                        const unsigned number_of_sources,
-                        const unsigned number_of_targets,
-                        const std::vector<NodeBucket> &search_space_with_buckets,
-                        std::vector<EdgeDistance> &distances_table,
-                        const std::vector<NodeID> &middle_nodes_table,
-                        SearchEngineData<mld::Algorithm> &engine_working_data)
-{
-    engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes(),
-                                                                 facade.GetMaxBorderNodeID() + 1);
-
-    for (unsigned column_idx = 0; column_idx < number_of_targets; ++column_idx)
-    {
-        // Step 1: Get source and target phantom nodes that were used in the bucketed search
-        auto source_phantom_index = source_index;
-        auto target_phantom_index = target_indices[column_idx];
-        const auto &source_phantom = phantom_nodes[source_phantom_index];
-        const auto &target_phantom = phantom_nodes[target_phantom_index];
-
-        const auto location = DIRECTION == FORWARD_DIRECTION
-                                  ? row_idx * number_of_targets + column_idx
-                                  : row_idx + column_idx * number_of_sources;
-
-        if (source_phantom_index == target_phantom_index)
-        {
-            distances_table[location] = 0.0;
-            continue;
-        }
-
-        NodeID middle_node_id = middle_nodes_table[location];
-
-        if (middle_node_id == SPECIAL_NODEID) // takes care of one-ways
-        {
-            distances_table[location] = INVALID_EDGE_DISTANCE;
-            continue;
-        }
-
-        // Step 2: Find path from source to middle node
-        PackedPath packed_path =
-            mld::retrievePackedPathFromSingleManyToManyHeap<DIRECTION>(query_heap, middle_node_id);
-
-        if (DIRECTION == FORWARD_DIRECTION)
-        {
-            std::reverse(packed_path.begin(), packed_path.end());
-        }
-
-        auto &forward_heap = *engine_working_data.forward_heap_1;
-        auto &reverse_heap = *engine_working_data.reverse_heap_1;
-        EdgeWeight weight = INVALID_EDGE_WEIGHT;
-        std::vector<NodeID> unpacked_nodes_from_source;
-        std::vector<EdgeID> unpacked_edges;
-        std::tie(weight, unpacked_nodes_from_source, unpacked_edges) =
-            unpackPathAndCalculateDistance(engine_working_data,
-                                           facade,
-                                           forward_heap,
-                                           reverse_heap,
-                                           DO_NOT_FORCE_LOOPS,
-                                           DO_NOT_FORCE_LOOPS,
-                                           INVALID_EDGE_WEIGHT,
-                                           packed_path,
-                                           middle_node_id,
-                                           source_phantom);
-
-        // Step 3: Find path from middle to target node
-        packed_path.clear();
-        retrievePackedPathFromSearchSpace<DIRECTION>(
-            middle_node_id, column_idx, search_space_with_buckets, packed_path);
-
-        if (DIRECTION == REVERSE_DIRECTION)
-        {
-            std::reverse(packed_path.begin(), packed_path.end());
-        }
-
-        std::vector<NodeID> unpacked_nodes_to_target;
-        std::tie(weight, unpacked_nodes_to_target, unpacked_edges) =
-            unpackPathAndCalculateDistance(engine_working_data,
-                                           facade,
-                                           forward_heap,
-                                           reverse_heap,
-                                           DO_NOT_FORCE_LOOPS,
-                                           DO_NOT_FORCE_LOOPS,
-                                           INVALID_EDGE_WEIGHT,
-                                           packed_path,
-                                           middle_node_id,
-                                           target_phantom);
-
-        if (DIRECTION == REVERSE_DIRECTION)
-        {
-            std::swap(unpacked_nodes_to_target, unpacked_nodes_from_source);
-        }
-
-        // Step 4: Compute annotation value along the path nodes without the target node
-        auto annotation = 0.0;
-
-        for (auto node = unpacked_nodes_from_source.begin(),
-                  last_node = std::prev(unpacked_nodes_from_source.end());
-             node != last_node;
-             ++node)
-        {
-            annotation += computeEdgeDistance(facade, *node);
-        }
-
-        for (auto node = unpacked_nodes_to_target.begin(),
-                  last_node = std::prev(unpacked_nodes_to_target.end());
-             node != last_node;
-             ++node)
-        {
-            annotation += computeEdgeDistance(facade, *node);
-        }
-
-        // Step 5: Get phantom node offsets and compute the annotation value
-        EdgeDistance source_offset = 0., target_offset = 0.;
-        {
-            // ⚠ for REVERSE_DIRECTION original source and target phantom nodes are swapped
-            if (DIRECTION == REVERSE_DIRECTION)
-            {
-                std::swap(source_phantom_index, target_phantom_index);
-            }
-            const auto &source_phantom = phantom_nodes[source_phantom_index];
-            const auto &target_phantom = phantom_nodes[target_phantom_index];
-
-            NodeID source_node = unpacked_nodes_from_source.front();
-            NodeID target_node = unpacked_nodes_to_target.back();
-
-            if (source_phantom.IsValidForwardSource() &&
-                source_phantom.forward_segment_id.id == source_node)
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0
-                //       to 3
-                //       -->s               <-- subtract offset to start at source
-                //          .........       <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                source_offset = source_phantom.GetForwardDistance();
-            }
-            else if (source_phantom.IsValidReverseSource() &&
-                     source_phantom.reverse_segment_id.id == source_node)
-            {
-                //       ............    <-- calculateEGBAnnotation returns distance from 0 to 3
-                //          s<-------    <-- subtract offset to start at source
-                //       ...             <-- want this distance
-                // entry 0---1---2---3   <-- 3 is exit node
-                source_offset = source_phantom.GetReverseDistance();
-            }
-
-            if (target_phantom.IsValidForwardTarget() &&
-                target_phantom.forward_segment_id.id == target_node)
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0
-                //       to 3
-                //                   ++>t   <-- add offset to get to target
-                //       ................   <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                target_offset = target_phantom.GetForwardDistance();
-            }
-            else if (target_phantom.IsValidReverseTarget() &&
-                     target_phantom.reverse_segment_id.id == target_node)
-            {
-                //       ............       <-- calculateEGBAnnotation returns distance from 0
-                //       to 3
-                //                   <++t   <-- add offset to get from target
-                //       ................   <-- want this distance as result
-                // entry 0---1---2---3---   <-- 3 is exit node
-                target_offset = target_phantom.GetReverseDistance();
-            }
-        }
-
-        distances_table[location] = -source_offset + annotation + target_offset;
-    }
-}
-
 template <bool DIRECTION>
 std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
 manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
@@ -815,7 +546,8 @@ manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
 
     std::vector<EdgeWeight> weights_table(number_of_entries, INVALID_EDGE_WEIGHT);
     std::vector<EdgeDuration> durations_table(number_of_entries, MAXIMAL_EDGE_DURATION);
-    std::vector<EdgeDistance> distances_table;
+    std::vector<EdgeDistance> distances_table(calculate_distance ? number_of_entries : 0,
+                                              INVALID_EDGE_DISTANCE);
     std::vector<NodeID> middle_nodes_table(number_of_entries, SPECIAL_NODEID);
 
     std::vector<NodeBucket> search_space_with_buckets;
@@ -874,25 +606,9 @@ manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                                           search_space_with_buckets,
                                           weights_table,
                                           durations_table,
-                                          middle_nodes_table,
-                                          source_phantom);
-        }
-
-        if (calculate_distance)
-        {
-            distances_table.resize(number_of_entries, INVALID_EDGE_DISTANCE);
-            calculateDistances<DIRECTION>(query_heap,
-                                          facade,
-                                          phantom_nodes,
-                                          target_indices, // source_indices
-                                          row_idx,
-                                          source_index,
-                                          number_of_sources,
-                                          number_of_targets,
-                                          search_space_with_buckets,
                                           distances_table,
                                           middle_nodes_table,
-                                          engine_working_data);
+                                          source_phantom);
         }
     }
 
@@ -920,12 +636,8 @@ manyToManySearch(SearchEngineData<mld::Algorithm> &engine_working_data,
                  const std::vector<PhantomNode> &phantom_nodes,
                  const std::vector<std::size_t> &source_indices,
                  const std::vector<std::size_t> &target_indices,
-                 const bool calculate_distance,
-                 const bool calculate_duration)
+                 const bool calculate_distance)
 {
-    (void)calculate_duration; // flag stub to use for calculating distances in matrix in mld in the
-                              // future
-
     if (source_indices.size() == 1)
     { // TODO: check if target_indices.size() == 1 and do a bi-directional search
         return mld::oneToManySearch<FORWARD_DIRECTION>(engine_working_data,

src/extractor/compressed_edge_container.cpp

@@ -396,5 +396,5 @@ std::unique_ptr<SegmentDataContainer> CompressedEdgeContainer::ToSegmentData()
 
     return std::move(segment_data);
 }
-} // namespace extractor
-} // namespace osrm
+}
+}

src/extractor/edge_based_graph_factory.cpp

@@ -51,7 +51,7 @@ template <> struct hash<std::pair<NodeID, NodeID>>
         return seed;
     }
 };
-} // namespace std
+}
 
 // Buffer size of turn_indexes_write_buffer to reduce number of write(v) syscals
 const constexpr int TURN_INDEX_WRITE_BUFFER_SIZE = 1000;
@@ -114,6 +114,13 @@ void EdgeBasedGraphFactory::GetEdgeBasedNodeDurations(
     swap(m_edge_based_node_durations, output_node_durations);
 }
 
+void EdgeBasedGraphFactory::GetEdgeBasedNodeDistances(
+    std::vector<EdgeDistance> &output_node_distances)
+{
+    using std::swap; // Koenig swap
+    swap(m_edge_based_node_distances, output_node_distances);
+}
+
 std::uint32_t EdgeBasedGraphFactory::GetConnectivityChecksum() const
 {
     return m_connectivity_checksum;
@@ -291,8 +298,12 @@ unsigned EdgeBasedGraphFactory::LabelEdgeBasedNodes()
 {
     // heuristic: node-based graph node is a simple intersection with four edges
     // (edge-based nodes)
-    m_edge_based_node_weights.reserve(4 * m_node_based_graph.GetNumberOfNodes());
-    m_edge_based_node_durations.reserve(4 * m_node_based_graph.GetNumberOfNodes());
+    constexpr std::size_t ESTIMATED_EDGE_COUNT = 4;
+    m_edge_based_node_weights.reserve(ESTIMATED_EDGE_COUNT * m_node_based_graph.GetNumberOfNodes());
+    m_edge_based_node_durations.reserve(ESTIMATED_EDGE_COUNT *
+                                        m_node_based_graph.GetNumberOfNodes());
+    m_edge_based_node_distances.reserve(ESTIMATED_EDGE_COUNT *
+                                        m_node_based_graph.GetNumberOfNodes());
     nbe_to_ebn_mapping.resize(m_node_based_graph.GetEdgeCapacity(), SPECIAL_NODEID);
 
     // renumber edge based node of outgoing edges
@@ -310,6 +321,7 @@ unsigned EdgeBasedGraphFactory::LabelEdgeBasedNodes()
 
             m_edge_based_node_weights.push_back(edge_data.weight);
             m_edge_based_node_durations.push_back(edge_data.duration);
+            m_edge_based_node_distances.push_back(edge_data.distance);
 
             BOOST_ASSERT(numbered_edges_count < m_node_based_graph.GetNumberOfEdges());
             nbe_to_ebn_mapping[current_edge] = numbered_edges_count;
@@ -407,6 +419,8 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const WayRestrictionMap &way_re
             m_edge_based_node_weights.push_back(ebn_weight);
             m_edge_based_node_durations.push_back(
                 m_edge_based_node_durations[nbe_to_ebn_mapping[eid]]);
+            m_edge_based_node_distances.push_back(
+                m_edge_based_node_distances[nbe_to_ebn_mapping[eid]]);
 
             edge_based_node_id++;
             progress.PrintStatus(progress_counter++);
@@ -416,6 +430,7 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const WayRestrictionMap &way_re
     BOOST_ASSERT(m_edge_based_node_segments.size() == m_edge_based_node_is_startpoint.size());
     BOOST_ASSERT(m_number_of_edge_based_nodes == m_edge_based_node_weights.size());
     BOOST_ASSERT(m_number_of_edge_based_nodes == m_edge_based_node_durations.size());
+    BOOST_ASSERT(m_number_of_edge_based_nodes == m_edge_based_node_distances.size());
 
     util::Log() << "Generated " << m_number_of_edge_based_nodes << " nodes ("
                 << way_restriction_map.NumberOfDuplicatedNodes()
@@ -570,6 +585,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             const auto &road_legs_on_the_right,
             const auto &road_legs_on_the_left,
             const auto &edge_geometries) {
+
             const auto node_restricted =
                 isRestricted(node_along_road_entering,
                              intersection_node,
@@ -693,6 +709,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
         //
         tbb::filter_t<tbb::blocked_range<NodeID>, EdgesPipelineBufferPtr> processor_stage(
             tbb::filter::parallel, [&](const tbb::blocked_range<NodeID> &intersection_node_range) {
+
                 auto buffer = std::make_shared<EdgesPipelineBuffer>();
                 buffer->nodes_processed = intersection_node_range.size();
 
@@ -1031,6 +1048,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
         std::vector<EdgeWithData> delayed_data;
         tbb::filter_t<EdgesPipelineBufferPtr, void> output_stage(
             tbb::filter::serial_in_order, [&](auto buffer) {
+
                 routing_progress.PrintAddition(buffer->nodes_processed);
 
                 m_connectivity_checksum = buffer->checksum.update_checksum(m_connectivity_checksum);

src/extractor/extraction_containers.cpp

@@ -99,7 +99,7 @@ inline NodeID mapExternalToInternalNodeID(Iter first, Iter last, const OSMNodeID
     return (it == last || value < *it) ? SPECIAL_NODEID
                                        : static_cast<NodeID>(std::distance(first, it));
 }
-} // namespace
+}
 
 namespace osrm
 {
@@ -744,6 +744,7 @@ void ExtractionContainers::PrepareManeuverOverrides()
      **/
     auto const find_turn_from_way_tofrom_nodes = [&](auto const &from_segment,
                                                      auto const &to_segment) {
+
         if (from_segment.first_segment_source_id == to_segment.first_segment_source_id)
         {
             return NodeBasedTurn{osm_node_to_internal_nbn(from_segment.first_segment_target_id),
@@ -860,6 +861,7 @@ void ExtractionContainers::PrepareManeuverOverrides()
     // Later, the UnresolvedManeuverOverride will be converted into a final ManeuverOverride
     // once the edge-based-node IDs are generated by the edge-based-graph-factory
     const auto transform = [&](const auto &external, auto &internal) {
+
         // Create a stub override
         auto maneuver_override =
             UnresolvedManeuverOverride{{},

src/extractor/extractor.cpp

@@ -242,6 +242,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
     std::vector<bool> node_is_startpoint;
     std::vector<EdgeWeight> edge_based_node_weights;
     std::vector<EdgeDuration> edge_based_node_durations;
+    std::vector<EdgeDistance> edge_based_node_distances;
     std::uint32_t ebg_connectivity_checksum = 0;
 
     // Create a node-based graph from the OSRM file
@@ -322,6 +323,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
                                node_is_startpoint,
                                edge_based_node_weights,
                                edge_based_node_durations,
+                               edge_based_node_distances,
                                edge_based_edge_list,
                                ebg_connectivity_checksum);
 
@@ -345,8 +347,10 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
 
     util::Log() << "Saving edge-based node weights to file.";
     TIMER_START(timer_write_node_weights);
-    extractor::files::writeEdgeBasedNodeWeightsDurations(
-        config.GetPath(".osrm.enw"), edge_based_node_weights, edge_based_node_durations);
+    extractor::files::writeEdgeBasedNodeWeightsDurationsDistances(config.GetPath(".osrm.enw"),
+                                                                  edge_based_node_weights,
+                                                                  edge_based_node_durations,
+                                                                  edge_based_node_distances);
     TIMER_STOP(timer_write_node_weights);
     util::Log() << "Done writing. (" << TIMER_SEC(timer_write_node_weights) << ")";
 
@@ -736,6 +740,7 @@ EdgeID Extractor::BuildEdgeExpandedGraph(
     std::vector<bool> &node_is_startpoint,
     std::vector<EdgeWeight> &edge_based_node_weights,
     std::vector<EdgeDuration> &edge_based_node_durations,
+    std::vector<EdgeDistance> &edge_based_node_distances,
     util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
     std::uint32_t &connectivity_checksum)
 {
@@ -786,6 +791,7 @@ EdgeID Extractor::BuildEdgeExpandedGraph(
     edge_based_graph_factory.GetStartPointMarkers(node_is_startpoint);
     edge_based_graph_factory.GetEdgeBasedNodeWeights(edge_based_node_weights);
     edge_based_graph_factory.GetEdgeBasedNodeDurations(edge_based_node_durations);
+    edge_based_graph_factory.GetEdgeBasedNodeDistances(edge_based_node_distances);
     connectivity_checksum = edge_based_graph_factory.GetConnectivityChecksum();
 
     return number_of_edge_based_nodes;

src/extractor/graph_compressor.cpp

@@ -259,7 +259,6 @@ void GraphCompressor::Compress(
                 const auto forward_weight2 = fwd_edge_data2.weight;
                 const auto forward_duration1 = fwd_edge_data1.duration;
                 const auto forward_duration2 = fwd_edge_data2.duration;
-                // const auto forward_distance1 = fwd_edge_data1.distance;
                 const auto forward_distance2 = fwd_edge_data2.distance;
 
                 BOOST_ASSERT(0 != forward_weight1);
@@ -269,9 +268,18 @@ void GraphCompressor::Compress(
                 const auto reverse_weight2 = rev_edge_data2.weight;
                 const auto reverse_duration1 = rev_edge_data1.duration;
                 const auto reverse_duration2 = rev_edge_data2.duration;
-                // const auto reverse_distance1 = rev_edge_data1.distance;
                 const auto reverse_distance2 = rev_edge_data2.distance;
 
+#ifndef NDEBUG
+                // Because distances are symmetrical, we only need one
+                // per edge - here we double-check that they match
+                // their mirrors.
+                const auto reverse_distance1 = rev_edge_data1.distance;
+                const auto forward_distance1 = fwd_edge_data1.distance;
+                BOOST_ASSERT(forward_distance1 == reverse_distance2);
+                BOOST_ASSERT(forward_distance2 == reverse_distance1);
+#endif
+
                 BOOST_ASSERT(0 != reverse_weight1);
                 BOOST_ASSERT(0 != reverse_weight2);
 
@@ -283,7 +291,7 @@ void GraphCompressor::Compress(
                 graph.GetEdgeData(forward_e1).duration += forward_duration2;
                 graph.GetEdgeData(reverse_e1).duration += reverse_duration2;
 
-                // add duration of e2's to e1
+                // add distance of e2's to e1
                 graph.GetEdgeData(forward_e1).distance += forward_distance2;
                 graph.GetEdgeData(reverse_e1).distance += reverse_distance2;
 
@@ -368,5 +376,5 @@ void GraphCompressor::PrintStatistics(unsigned original_number_of_nodes,
     util::Log() << "Node compression ratio: " << new_node_count / (double)original_number_of_nodes;
     util::Log() << "Edge compression ratio: " << new_edge_count / (double)original_number_of_edges;
 }
-} // namespace extractor
-} // namespace osrm
+}
+}

src/nodejs/node_osrm.cpp

@@ -363,7 +363,7 @@ NAN_METHOD(Engine::nearest) //
 
  * @param {Function} callback
  *
- * @returns {Object} containing `durations`, `sources`, and `destinations`.
+ * @returns {Object} containing `durations`, `distances`, `sources`, and `destinations`.
  * **`durations`**: array of arrays that stores the matrix in row-major order. `durations[i][j]` gives the travel time from the i-th waypoint to the j-th waypoint.
  *                  Values are given in seconds.
  * **`distances`**: array of arrays that stores the matrix in row-major order. `distances[i][j]` gives the travel time from the i-th waypoint to the j-th waypoint.

src/partitioner/partitioner.cpp

@@ -147,12 +147,15 @@ int Partitioner::Run(const PartitionerConfig &config)
     {
         std::vector<EdgeWeight> node_weights;
         std::vector<EdgeDuration> node_durations;
+        std::vector<EdgeDuration> node_distances;
         extractor::files::readEdgeBasedNodeWeightsDurations(
             config.GetPath(".osrm.enw"), node_weights, node_durations);
+        extractor::files::readEdgeBasedNodeDistances(config.GetPath(".osrm.enw"), node_distances);
         util::inplacePermutation(node_weights.begin(), node_weights.end(), permutation);
         util::inplacePermutation(node_durations.begin(), node_durations.end(), permutation);
-        extractor::files::writeEdgeBasedNodeWeightsDurations(
-            config.GetPath(".osrm.enw"), node_weights, node_durations);
+        util::inplacePermutation(node_distances.begin(), node_distances.end(), permutation);
+        extractor::files::writeEdgeBasedNodeWeightsDurationsDistances(
+            config.GetPath(".osrm.enw"), node_weights, node_durations, node_distances);
     }
     {
         const auto &filename = config.GetPath(".osrm.maneuver_overrides");

src/storage/storage.cpp

@@ -51,8 +51,8 @@ struct RegionHandle
     std::uint16_t shm_key;
 };
 
-auto setupRegion(SharedRegionRegister &shared_register,
-                 const std::unique_ptr<storage::BaseDataLayout> &layout)
+RegionHandle setupRegion(SharedRegionRegister &shared_register,
+                         const storage::BaseDataLayout &layout)
 {
     // This is safe because we have an exclusive lock for all osrm-datastore processes.
     auto shm_key = shared_register.ReserveKey();
@@ -73,7 +73,7 @@ auto setupRegion(SharedRegionRegister &shared_register,
     auto encoded_static_layout = writer.GetBuffer();
 
     // Allocate shared memory block
-    auto regions_size = encoded_static_layout.size() + layout->GetSizeOfLayout();
+    auto regions_size = encoded_static_layout.size() + layout.GetSizeOfLayout();
     util::Log() << "Data layout has a size of " << encoded_static_layout.size() << " bytes";
     util::Log() << "Allocating shared memory of " << regions_size << " bytes";
     auto memory = makeSharedMemory(shm_key, regions_size);
@@ -165,12 +165,9 @@ bool swapData(Monitor &monitor,
 
     return true;
 }
-} // namespace
+}
 
-Storage::Storage(StorageConfig config_) : config(std::move(config_)) {}
-
-void Storage::readBlocks(const boost::filesystem::path &path,
-                         std::unique_ptr<storage::BaseDataLayout> &layout)
+void populateLayoutFromFile(const boost::filesystem::path &path, storage::BaseDataLayout &layout)
 {
     tar::FileReader reader(path, tar::FileReader::VerifyFingerprint);
 
@@ -183,11 +180,13 @@ void Storage::readBlocks(const boost::filesystem::path &path,
         if (name_end == std::string::npos)
         {
             auto number_of_elements = reader.ReadElementCount64(entry.name);
-            layout->SetBlock(entry.name, Block{number_of_elements, entry.size, entry.offset});
+            layout.SetBlock(entry.name, Block{number_of_elements, entry.size, entry.offset});
         }
     }
 }
 
+Storage::Storage(StorageConfig config_) : config(std::move(config_)) {}
+
 int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric)
 {
     BOOST_ASSERT_MSG(config.IsValid(), "Invalid storage config");
@@ -246,10 +245,10 @@ int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric
         auto static_memory = makeSharedMemory(static_region.shm_key);
 
         std::unique_ptr<storage::BaseDataLayout> static_layout =
-            std::make_unique<storage::DataLayout>();
+            std::make_unique<storage::ContiguousDataLayout>();
         io::BufferReader reader(reinterpret_cast<char *>(static_memory->Ptr()),
                                 static_memory->Size());
-        serialization::read(reader, static_layout);
+        serialization::read(reader, *static_layout);
         auto layout_size = reader.GetPosition();
         auto *data_ptr = reinterpret_cast<char *>(static_memory->Ptr()) + layout_size;
 
@@ -259,20 +258,20 @@ int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric
     else
     {
         std::unique_ptr<storage::BaseDataLayout> static_layout =
-            std::make_unique<storage::DataLayout>();
-        Storage::PopulateLayoutWithRTree(static_layout);
+            std::make_unique<storage::ContiguousDataLayout>();
+        Storage::PopulateLayoutWithRTree(*static_layout);
         std::vector<std::pair<bool, boost::filesystem::path>> files = Storage::GetStaticFiles();
-        Storage::PopulateLayout(static_layout, files);
-        auto static_handle = setupRegion(shared_register, static_layout);
+        Storage::PopulateLayout(*static_layout, files);
+        auto static_handle = setupRegion(shared_register, *static_layout);
         regions.push_back({static_handle.data_ptr, std::move(static_layout)});
         handles[dataset_name + "/static"] = std::move(static_handle);
     }
 
     std::unique_ptr<storage::BaseDataLayout> updatable_layout =
-        std::make_unique<storage::DataLayout>();
+        std::make_unique<storage::ContiguousDataLayout>();
     std::vector<std::pair<bool, boost::filesystem::path>> files = Storage::GetUpdatableFiles();
-    Storage::PopulateLayout(updatable_layout, files);
-    auto updatable_handle = setupRegion(shared_register, updatable_layout);
+    Storage::PopulateLayout(*updatable_layout, files);
+    auto updatable_handle = setupRegion(shared_register, *updatable_layout);
     regions.push_back({updatable_handle.data_ptr, std::move(updatable_layout)});
     handles[dataset_name + "/updatable"] = std::move(updatable_handle);
 
@@ -344,19 +343,18 @@ std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetUpdatableFiles
     return files;
 }
 
-std::string Storage::PopulateLayoutWithRTree(std::unique_ptr<storage::BaseDataLayout> &layout)
+std::string Storage::PopulateLayoutWithRTree(storage::BaseDataLayout &layout)
 {
     // Figure out the path to the rtree file (it's not a tar file)
     auto absolute_file_index_path = boost::filesystem::absolute(config.GetPath(".osrm.fileIndex"));
 
     // Convert the boost::filesystem::path object into a plain string
     // that can then be stored as a member of an allocator object
-    std::string rtree_filename = absolute_file_index_path.string();
+    auto rtree_filename = absolute_file_index_path.string();
 
     // Here, we hardcode the special file_index_path block name.
     // The important bit here is that the "offset" is set to zero
-    layout->SetBlock("/common/rtree/file_index_path",
-                     make_block<char>(rtree_filename.length() + 1));
+    layout.SetBlock("/common/rtree/file_index_path", make_block<char>(rtree_filename.length() + 1));
 
     return rtree_filename;
 }
@@ -364,16 +362,16 @@ std::string Storage::PopulateLayoutWithRTree(std::unique_ptr<storage::BaseDataLa
 /**
  * This function examines all our data files and figures out how much
  * memory needs to be allocated, and the position of each data structure
- * in that big block.  It updates the fields in the std::unique_ptr<BaseDataLayout> parameter.
+ * in that big block.  It updates the fields in the layout parameter.
  */
-void Storage::PopulateLayout(std::unique_ptr<storage::BaseDataLayout> &layout,
-                             std::vector<std::pair<bool, boost::filesystem::path>> files)
+void Storage::PopulateLayout(storage::BaseDataLayout &layout,
+                             const std::vector<std::pair<bool, boost::filesystem::path>> &files)
 {
     for (const auto &file : files)
     {
         if (boost::filesystem::exists(file.second))
         {
-            readBlocks(file.second, layout);
+            populateLayoutFromFile(file.second, layout);
         }
     }
 }
@@ -586,5 +584,5 @@ void Storage::PopulateUpdatableData(const SharedDataIndex &index)
         }
     }
 }
-} // namespace storage
-} // namespace osrm
+}
+}

src/tools/contract.cpp

@@ -81,11 +81,7 @@ return_code parseArguments(int argc,
         "time-zone-file",
         boost::program_options::value<std::string>(&contractor_config.updater_config.tz_file_path),
         "Required for conditional turn restriction parsing, provide a geojson file containing "
-        "time zone boundaries")(
-        "cache-distances",
-        boost::program_options::bool_switch(&contractor_config.cache_distances)
-            ->default_value(false),
-        "Store distances for CH edges, avoiding the need for query-time re-calculation.");
+        "time zone boundaries");
 
     // hidden options, will be allowed on command line, but will not be shown to the user
     boost::program_options::options_description hidden_options("Hidden options");

src/tools/store.cpp

@@ -52,8 +52,8 @@ void listRegions(bool show_blocks)
             auto memory = makeSharedMemory(region.shm_key);
             io::BufferReader reader(reinterpret_cast<char *>(memory->Ptr()), memory->Size());
 
-            std::unique_ptr<BaseDataLayout> layout = std::make_unique<DataLayout>();
-            serialization::read(reader, layout);
+            std::unique_ptr<BaseDataLayout> layout = std::make_unique<ContiguousDataLayout>();
+            serialization::read(reader, *layout);
 
             std::vector<std::string> block_names;
             layout->List("", std::back_inserter(block_names));

test/data/Makefile

@@ -74,11 +74,11 @@ benchmark: data $(DATA_NAME).requests
 	$(TIMER) "queries\tCoreCH" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"
 	@cat osrm-routed.pid | xargs kill
 	@rm osrm-routed.pid
-	# @/bin/sh -c '$(OSRM_ROUTED) --algorithm=MLD mld/$(DATA_NAME).osrm > /dev/null & echo "$$!" > osrm-routed.pid'
-	# @sleep 1
-	# $(TIMER) "queries\tMLD" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"
-	# @cat osrm-routed.pid | xargs kill
-	# @rm osrm-routed.pid
+	@/bin/sh -c '$(OSRM_ROUTED) --algorithm=MLD mld/$(DATA_NAME).osrm > /dev/null & echo "$$!" > osrm-routed.pid'
+	@sleep 1
+	$(TIMER) "queries\tMLD" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"
+	@cat osrm-routed.pid | xargs kill
+	@rm osrm-routed.pid
 	@echo "**** timings ***"
 	@cat /tmp/osrm.timings
 	@echo "****************"

test/nodejs/match.js

@@ -257,19 +257,19 @@ test('match: throws on invalid config param', function(assert) {
         /format must be a string:/);
 });
 
-// test('match: match in Monaco without motorways', function(assert) {
-//     assert.plan(3);
-//     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-//     var options = {
-//         coordinates: three_test_coordinates,
-//         exclude: ['motorway']
-//     };
-//     osrm.match(options, function(err, response) {
-//         assert.ifError(err);
-//         assert.equal(response.tracepoints.length, 3);
-//         assert.equal(response.matchings.length, 1);
-//     });
-// });
+test('match: match in Monaco without motorways', function(assert) {
+    assert.plan(3);
+    var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+    var options = {
+        coordinates: three_test_coordinates,
+        exclude: ['motorway']
+    };
+    osrm.match(options, function(err, response) {
+        assert.ifError(err);
+        assert.equal(response.tracepoints.length, 3);
+        assert.equal(response.matchings.length, 1);
+    });
+});
 
 test('match: throws on invalid waypoints values needs at least two', function(assert) {
     assert.plan(1);

test/nodejs/nearest.js

@@ -73,15 +73,15 @@ test('nearest: throws on invalid args', function(assert) {
         /format must be a string:/);
 });
 
-// test('nearest: nearest in Monaco without motorways', function(assert) {
-//     assert.plan(2);
-//     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-//     var options = {
-//         coordinates: [two_test_coordinates[0]],
-//         exclude: ['motorway']
-//     };
-//     osrm.nearest(options, function(err, response) {
-//         assert.ifError(err);
-//         assert.equal(response.waypoints.length, 1);
-//     });
-// });
+test('nearest: nearest in Monaco without motorways', function(assert) {
+    assert.plan(2);
+    var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+    var options = {
+        coordinates: [two_test_coordinates[0]],
+        exclude: ['motorway']
+    };
+    osrm.nearest(options, function(err, response) {
+        assert.ifError(err);
+        assert.equal(response.waypoints.length, 1);
+    });
+});

test/nodejs/route.js

@@ -592,17 +592,17 @@ test('route:  in Monaco with custom limits on MLD', function(assert) {
     });
 });
 
-// test('route: route in Monaco without motorways', function(assert) {
-//     assert.plan(3);
-//     var osrm = new OSRM({path: monaco_mld_path, algorithm: 'MLD'});
-//     var options = {
-//         coordinates: two_test_coordinates,
-//         exclude: ['motorway']
-//     };
-//     osrm.route(options, function(err, response) {
-//         assert.ifError(err);
-//         assert.equal(response.waypoints.length, 2);
-//         assert.equal(response.routes.length, 1);
-//     });
-// });
+test('route: route in Monaco without motorways', function(assert) {
+    assert.plan(3);
+    var osrm = new OSRM({path: monaco_mld_path, algorithm: 'MLD'});
+    var options = {
+        coordinates: two_test_coordinates,
+        exclude: ['motorway']
+    };
+    osrm.route(options, function(err, response) {
+        assert.ifError(err);
+        assert.equal(response.waypoints.length, 2);
+        assert.equal(response.routes.length, 1);
+    });
+});
 

test/nodejs/table.js

@@ -233,17 +233,17 @@ tables.forEach(function(annotation) {
         });
     });
 
-    // test('table: ' + annotation + ' table in Monaco without motorways', function(assert) {
-    //     assert.plan(1);
-    //     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-    //     var options = {
-    //         coordinates: two_test_coordinates,
-    //         exclude: ['motorway'],
-    //         annotations: [annotation.slice(0,-1)]
-    //     };
-    //     osrm.table(options, function(err, response) {
-    //         assert.equal(response[annotation].length, 2);
-    //     });
-    // });
+    test('table: ' + annotation + ' table in Monaco without motorways', function(assert) {
+        assert.plan(1);
+        var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+        var options = {
+            coordinates: two_test_coordinates,
+            exclude: ['motorway'],
+            annotations: [annotation.slice(0,-1)]
+        };
+        osrm.table(options, function(err, response) {
+            assert.equal(response[annotation].length, 2);
+        });
+    });
 });
 

test/nodejs/trip.js

@@ -342,17 +342,17 @@ test('trip: fixed start and end combinations', function(assert) {
     assert.end();
 });
 
-// test('trip: trip in Monaco without motorways', function(assert) {
-//     assert.plan(3);
-//     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-//     var options = {
-//         coordinates: two_test_coordinates,
-//         exclude: ['motorway']
-//     };
-//     osrm.trip(options, function(err, response) {
-//         assert.ifError(err);
-//         assert.equal(response.waypoints.length, 2);
-//         assert.equal(response.trips.length, 1);
-//     });
-// });
+test('trip: trip in Monaco without motorways', function(assert) {
+    assert.plan(3);
+    var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+    var options = {
+        coordinates: two_test_coordinates,
+        exclude: ['motorway']
+    };
+    osrm.trip(options, function(err, response) {
+        assert.ifError(err);
+        assert.equal(response.waypoints.length, 2);
+        assert.equal(response.trips.length, 1);
+    });
+});
 

unit_tests/contractor/contracted_edge_container.cpp

@@ -17,7 +17,8 @@ bool operator!=(const QueryEdge &lhs, const QueryEdge &rhs) { return !(lhs == rh
 std::ostream &operator<<(std::ostream &out, const QueryEdge::EdgeData &data)
 {
     out << "{" << data.turn_id << ", " << data.shortcut << ", " << data.duration << ", "
-        << data.weight << ", " << data.forward << ", " << data.backward << "}";
+        << data.distance << ", " << data.weight << ", " << data.forward << ", " << data.backward
+        << "}";
     return out;
 }
 
@@ -31,79 +32,79 @@ std::ostream &operator<<(std::ostream &out, const QueryEdge &edge)
 
 BOOST_AUTO_TEST_SUITE(contracted_edge_container)
 
-// BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_graph)
-// {
-//     ContractedEdgeContainer container;
+BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_graph)
+{
+    ContractedEdgeContainer container;
 
-//     std::vector<QueryEdge> edges;
-//     edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{2, 0, {3, false, 3, 6, false, true}});
-//     edges.push_back(QueryEdge{2, 1, {4, false, 3, 6, false, true}});
-//     container.Insert(edges);
+    std::vector<QueryEdge> edges;
+    edges.push_back(QueryEdge{0, 1, {1, false, 3, 3, 6, true, false}});
+    edges.push_back(QueryEdge{1, 2, {2, false, 3, 3, 6, true, false}});
+    edges.push_back(QueryEdge{2, 0, {3, false, 3, 3, 6, false, true}});
+    edges.push_back(QueryEdge{2, 1, {4, false, 3, 3, 6, false, true}});
+    container.Insert(edges);
 
-//     edges.clear();
-//     edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-//     edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-//     container.Merge(edges);
+    edges.clear();
+    edges.push_back(QueryEdge{0, 1, {1, false, 3, 3, 6, true, false}});
+    edges.push_back(QueryEdge{1, 2, {2, false, 3, 3, 6, true, false}});
+    edges.push_back(QueryEdge{2, 0, {3, false, 12, 12, 24, false, true}});
+    edges.push_back(QueryEdge{2, 1, {4, false, 12, 12, 24, false, true}});
+    container.Merge(edges);
 
-//     edges.clear();
-//     edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
-//     container.Merge(edges);
+    edges.clear();
+    edges.push_back(QueryEdge{1, 4, {5, false, 3, 3, 6, true, false}});
+    container.Merge(edges);
 
-//     std::vector<QueryEdge> reference_edges;
-//     reference_edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{2, 0, {3, false, 3, 6, false, true}});
-//     reference_edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-//     reference_edges.push_back(QueryEdge{2, 1, {4, false, 3, 6, false, true}});
-//     reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-//     CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
+    std::vector<QueryEdge> reference_edges;
+    reference_edges.push_back(QueryEdge{0, 1, {1, false, 3, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{1, 2, {2, false, 3, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{1, 4, {5, false, 3, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{2, 0, {3, false, 3, 3, 6, false, true}});
+    reference_edges.push_back(QueryEdge{2, 0, {3, false, 12, 12, 24, false, true}});
+    reference_edges.push_back(QueryEdge{2, 1, {4, false, 3, 3, 6, false, true}});
+    reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 12, 24, false, true}});
+    CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
 
-//     auto filters = container.MakeEdgeFilters();
-//     BOOST_CHECK_EQUAL(filters.size(), 2);
+    auto filters = container.MakeEdgeFilters();
+    BOOST_CHECK_EQUAL(filters.size(), 2);
 
-//     REQUIRE_SIZE_RANGE(filters[0], 7);
-//     CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true, true, true);
+    REQUIRE_SIZE_RANGE(filters[0], 7);
+    CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true, true, true);
 
-//     REQUIRE_SIZE_RANGE(filters[1], 7);
-//     CHECK_EQUAL_RANGE(filters[1], true, true, true, true, false, true, false);
-// }
+    REQUIRE_SIZE_RANGE(filters[1], 7);
+    CHECK_EQUAL_RANGE(filters[1], true, true, true, true, false, true, false);
+}
 
-// BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_disjoint_graph)
-// {
-//     ContractedEdgeContainer container;
+BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_disjoint_graph)
+{
+    ContractedEdgeContainer container;
 
-//     std::vector<QueryEdge> edges;
-//     edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
-//     edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-//     edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-//     container.Merge(edges);
+    std::vector<QueryEdge> edges;
+    edges.push_back(QueryEdge{0, 1, {1, false, 3, 3, 6, true, false}});
+    edges.push_back(QueryEdge{1, 2, {2, false, 3, 3, 6, true, false}});
+    edges.push_back(QueryEdge{2, 0, {3, false, 12, 12, 24, false, true}});
+    edges.push_back(QueryEdge{2, 1, {4, false, 12, 12, 24, false, true}});
+    container.Merge(edges);
 
-//     edges.clear();
-//     edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
-//     container.Merge(edges);
+    edges.clear();
+    edges.push_back(QueryEdge{1, 4, {5, false, 3, 3, 6, true, false}});
+    container.Merge(edges);
 
-//     std::vector<QueryEdge> reference_edges;
-//     reference_edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{1, 2, {2, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
-//     reference_edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-//     reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-//     CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
+    std::vector<QueryEdge> reference_edges;
+    reference_edges.push_back(QueryEdge{0, 1, {1, false, 3, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{1, 2, {2, false, 3, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{1, 4, {5, false, 3, 3, 6, true, false}});
+    reference_edges.push_back(QueryEdge{2, 0, {3, false, 12, 12, 24, false, true}});
+    reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 12, 24, false, true}});
+    CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
 
-//     auto filters = container.MakeEdgeFilters();
-//     BOOST_CHECK_EQUAL(filters.size(), 2);
+    auto filters = container.MakeEdgeFilters();
+    BOOST_CHECK_EQUAL(filters.size(), 2);
 
-//     REQUIRE_SIZE_RANGE(filters[0], 5);
-//     CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true);
+    REQUIRE_SIZE_RANGE(filters[0], 5);
+    CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true);
 
-//     REQUIRE_SIZE_RANGE(filters[1], 5);
-//     CHECK_EQUAL_RANGE(filters[1], false, false, true, false, false);
-// }
+    REQUIRE_SIZE_RANGE(filters[1], 5);
+    CHECK_EQUAL_RANGE(filters[1], false, false, true, false, false);
+}
 
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/contractor/graph_contractor.cpp

@@ -14,122 +14,122 @@ using namespace osrm::unit_test;
 
 BOOST_AUTO_TEST_SUITE(graph_contractor)
 
-// BOOST_AUTO_TEST_CASE(contract_graph)
-// {
-//     tbb::task_scheduler_init scheduler(1);
-//     /*
-//      *                 <--1--<
-//      * (0) >--3--> (1) >--3--> (3)
-//      *  v          ^  v          ^
-//      *   \        /    \         |
-//      *    1      1      1        1
-//      *     \    ^        \       /
-//      *      >(5)          > (4) >
-//      */
-//     std::vector<TestEdge> edges = {TestEdge{0, 1, 3},
-//                                    TestEdge{0, 5, 1},
-//                                    TestEdge{1, 3, 3},
-//                                    TestEdge{1, 4, 1},
-//                                    TestEdge{3, 1, 1},
-//                                    TestEdge{4, 3, 1},
-//                                    TestEdge{5, 1, 1}};
-//     auto reference_graph = makeGraph(edges);
+BOOST_AUTO_TEST_CASE(contract_graph)
+{
+    tbb::task_scheduler_init scheduler(1);
+    /*
+     *                 <--1--<
+     * (0) >--3--> (1) >--3--> (3)
+     *  v          ^  v          ^
+     *   \        /    \         |
+     *    1      1      1        1
+     *     \    ^        \       /
+     *      >(5)          > (4) >
+     */
+    std::vector<TestEdge> edges = {TestEdge{0, 1, 3},
+                                   TestEdge{0, 5, 1},
+                                   TestEdge{1, 3, 3},
+                                   TestEdge{1, 4, 1},
+                                   TestEdge{3, 1, 1},
+                                   TestEdge{4, 3, 1},
+                                   TestEdge{5, 1, 1}};
+    auto reference_graph = makeGraph(edges);
 
-//     auto contracted_graph = reference_graph;
-//     std::vector<bool> core = contractGraph(contracted_graph, {1, 1, 1, 1, 1, 1});
+    auto contracted_graph = reference_graph;
+    std::vector<bool> core = contractGraph(contracted_graph, {1, 1, 1, 1, 1, 1});
 
-//     // This contraction order is dependent on the priority caculation in the contractor
-//     // but deterministic for the same graph.
-//     CHECK_EQUAL_RANGE(core, false, false, false, false, false, false);
+    // This contraction order is dependent on the priority caculation in the contractor
+    // but deterministic for the same graph.
+    CHECK_EQUAL_RANGE(core, false, false, false, false, false, false);
 
-//     /* After contracting 0 and 2:
-//      *
-//      * Deltes edges 5 -> 0, 1 -> 0
-//      *
-//      *                 <--1--<
-//      * (0) ---3--> (1) >--3--> (3)
-//      *  \          ^  v          ^
-//      *   \        /    \         |
-//      *    1      1      1        1
-//      *     \    ^        \       /
-//      *      >(5)          > (4) >
-//      */
-//     reference_graph.DeleteEdgesTo(5, 0);
-//     reference_graph.DeleteEdgesTo(1, 0);
+    /* After contracting 0 and 2:
+     *
+     * Deltes edges 5 -> 0, 1 -> 0
+     *
+     *                 <--1--<
+     * (0) ---3--> (1) >--3--> (3)
+     *  \          ^  v          ^
+     *   \        /    \         |
+     *    1      1      1        1
+     *     \    ^        \       /
+     *      >(5)          > (4) >
+     */
+    reference_graph.DeleteEdgesTo(5, 0);
+    reference_graph.DeleteEdgesTo(1, 0);
 
-//     /* After contracting 5:
-//      *
-//      * Deletes edges 1 -> 5
-//      *
-//      *                 <--1--<
-//      * (0) ---3--> (1) >--3--> (3)
-//      *  \          ^  v          ^
-//      *   \        /    \         |
-//      *    1      1      1        1
-//      *     \    /        \       /
-//      *      >(5)          > (4) >
-//      */
-//     reference_graph.DeleteEdgesTo(5, 0);
-//     reference_graph.DeleteEdgesTo(1, 0);
+    /* After contracting 5:
+     *
+     * Deletes edges 1 -> 5
+     *
+     *                 <--1--<
+     * (0) ---3--> (1) >--3--> (3)
+     *  \          ^  v          ^
+     *   \        /    \         |
+     *    1      1      1        1
+     *     \    /        \       /
+     *      >(5)          > (4) >
+     */
+    reference_graph.DeleteEdgesTo(5, 0);
+    reference_graph.DeleteEdgesTo(1, 0);
 
-//      After contracting 3:
-//      *
-//      * Deletes edges 1 -> 3
-//      * Deletes edges 4 -> 3
-//      * Insert edge 4 -> 1
-//      *
-//      *                 <--1---
-//      * (0) ---3--> (1) >--3--- (3)
-//      *  \          ^  v ^        |
-//      *   \        /    \ \       |
-//      *    1      1      1 2      1
-//      *     \    /        \ \     /
-//      *      >(5)          > (4) >
+    /* After contracting 3:
+     *
+     * Deletes edges 1 -> 3
+     * Deletes edges 4 -> 3
+     * Insert edge 4 -> 1
+     *
+     *                 <--1---
+     * (0) ---3--> (1) >--3--- (3)
+     *  \          ^  v ^        |
+     *   \        /    \ \       |
+     *    1      1      1 2      1
+     *     \    /        \ \     /
+     *      >(5)          > (4) >
+     */
+    reference_graph.DeleteEdgesTo(1, 3);
+    reference_graph.DeleteEdgesTo(4, 3);
+    // Insert shortcut
+    reference_graph.InsertEdge(4, 1, {2, 4, 1.0, 3, 0, true, true, false});
 
-//     reference_graph.DeleteEdgesTo(1, 3);
-//     reference_graph.DeleteEdgesTo(4, 3);
-//     // Insert shortcut
-//     reference_graph.InsertEdge(4, 1, {2, 4, 3, 0, true, true, false});
+    /* After contracting 4:
+     *
+     * Delete edges 1 -> 4
+     *
+     *                 <--1---
+     * (0) ---3--> (1) >--3--- (3)
+     *  \          ^  v ^        |
+     *   \        /    \ \       |
+     *    1      1      1 2      1
+     *     \    /        \ \     /
+     *      >(5)          \ (4) >
+     */
+    reference_graph.DeleteEdgesTo(1, 4);
 
-//     /* After contracting 4:
-//      *
-//      * Delete edges 1 -> 4
-//      *
-//      *                 <--1---
-//      * (0) ---3--> (1) >--3--- (3)
-//      *  \          ^  v ^        |
-//      *   \        /    \ \       |
-//      *    1      1      1 2      1
-//      *     \    /        \ \     /
-//      *      >(5)          \ (4) >
-//      */
-//     reference_graph.DeleteEdgesTo(1, 4);
+    /* After contracting 1:
+     *
+     * Delete no edges.
+     *
+     *                 <--1---
+     * (0) ---3--> (1) >--3--- (3)
+     *  \          ^  v ^        |
+     *   \        /    \ \       |
+     *    1      1      1 2      1
+     *     \    /        \ \     /
+     *      >(5)          \ (4) >
+     */
 
-//     /* After contracting 1:
-//      *
-//      * Delete no edges.
-//      *
-//      *                 <--1---
-//      * (0) ---3--> (1) >--3--- (3)
-//      *  \          ^  v ^        |
-//      *   \        /    \ \       |
-//      *    1      1      1 2      1
-//      *     \    /        \ \     /
-//      *      >(5)          \ (4) >
-//      */
-
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(0), 2);
-//     BOOST_CHECK(contracted_graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-//     BOOST_CHECK(contracted_graph.FindEdge(0, 5) != SPECIAL_EDGEID);
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(1), 0);
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(2), 0);
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(3), 3);
-//     BOOST_CHECK(contracted_graph.FindEdge(3, 1) != SPECIAL_EDGEID);
-//     BOOST_CHECK(contracted_graph.FindEdge(3, 4) != SPECIAL_EDGEID);
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(4), 2);
-//     BOOST_CHECK(contracted_graph.FindEdge(4, 1) != SPECIAL_EDGEID);
-//     REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(5), 1);
-//     BOOST_CHECK(contracted_graph.FindEdge(5, 1) != SPECIAL_EDGEID);
-// }
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(0), 2);
+    BOOST_CHECK(contracted_graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(contracted_graph.FindEdge(0, 5) != SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(1), 0);
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(2), 0);
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(3), 3);
+    BOOST_CHECK(contracted_graph.FindEdge(3, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(contracted_graph.FindEdge(3, 4) != SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(4), 2);
+    BOOST_CHECK(contracted_graph.FindEdge(4, 1) != SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(5), 1);
+    BOOST_CHECK(contracted_graph.FindEdge(5, 1) != SPECIAL_EDGEID);
+}
 
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/contractor/helper.hpp

@@ -20,15 +20,19 @@ inline contractor::ContractorGraph makeGraph(const std::vector<TestEdge> &edges)
         unsigned target;
         int weight;
         std::tie(start, target, weight) = edge;
+        int duration = weight * 2;
+        float distance = 1.0;
         max_id = std::max(std::max(start, target), max_id);
         input_edges.push_back(contractor::ContractorEdge{
             start,
             target,
-            contractor::ContractorEdgeData{weight, weight * 2, 1.0, id++, 0, false, true, false}});
+            contractor::ContractorEdgeData{
+                weight, duration, distance, id++, 0, false, true, false}});
         input_edges.push_back(contractor::ContractorEdge{
             target,
             start,
-            contractor::ContractorEdgeData{weight, weight * 2, 1.0, id++, 0, false, false, true}});
+            contractor::ContractorEdgeData{
+                weight, duration, distance, id++, 0, false, false, true}});
     }
     std::sort(input_edges.begin(), input_edges.end());
 

unit_tests/customizer/cell_customization.cpp

@@ -27,6 +27,7 @@ auto makeGraph(const MultiLevelPartition &mlp, const std::vector<MockEdge> &mock
     {
         EdgeWeight weight;
         EdgeDuration duration;
+        EdgeDistance distance;
         bool forward;
         bool backward;
     };
@@ -36,8 +37,20 @@ auto makeGraph(const MultiLevelPartition &mlp, const std::vector<MockEdge> &mock
     for (const auto &m : mock_edges)
     {
         max_id = std::max<std::size_t>(max_id, std::max(m.start, m.target));
-        edges.push_back(Edge{m.start, m.target, m.weight, 2 * m.weight, true, false});
-        edges.push_back(Edge{m.target, m.start, m.weight, 2 * m.weight, false, true});
+        edges.push_back(Edge{m.start,
+                             m.target,
+                             m.weight,
+                             2 * m.weight,
+                             static_cast<EdgeDistance>(1.0),
+                             true,
+                             false});
+        edges.push_back(Edge{m.target,
+                             m.start,
+                             m.weight,
+                             2 * m.weight,
+                             static_cast<EdgeDistance>(1.0),
+                             false,
+                             true});
     }
     std::sort(edges.begin(), edges.end());
     return partitioner::MultiLevelGraph<EdgeData, osrm::storage::Ownership::Container>(

unit_tests/extractor/graph_compressor.cpp

@@ -1,296 +1,296 @@
-// #include "extractor/graph_compressor.hpp"
-// #include "extractor/compressed_edge_container.hpp"
-// #include "extractor/maneuver_override.hpp"
-// #include "extractor/restriction.hpp"
-// #include "util/node_based_graph.hpp"
-// #include "util/typedefs.hpp"
+#include "extractor/graph_compressor.hpp"
+#include "extractor/compressed_edge_container.hpp"
+#include "extractor/maneuver_override.hpp"
+#include "extractor/restriction.hpp"
+#include "util/node_based_graph.hpp"
+#include "util/typedefs.hpp"
 
-// #include "../unit_tests/mocks/mock_scripting_environment.hpp"
+#include "../unit_tests/mocks/mock_scripting_environment.hpp"
 
-// #include <boost/test/test_case_template.hpp>
-// #include <boost/test/unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/unit_test.hpp>
 
-// #include <iostream>
-// #include <unordered_set>
-// #include <vector>
+#include <iostream>
+#include <unordered_set>
+#include <vector>
 
-// BOOST_AUTO_TEST_SUITE(graph_compressor)
+BOOST_AUTO_TEST_SUITE(graph_compressor)
 
-// using namespace osrm;
-// using namespace osrm::extractor;
-// using InputEdge = util::NodeBasedDynamicGraph::InputEdge;
-// using Graph = util::NodeBasedDynamicGraph;
+using namespace osrm;
+using namespace osrm::extractor;
+using InputEdge = util::NodeBasedDynamicGraph::InputEdge;
+using Graph = util::NodeBasedDynamicGraph;
 
-// namespace
-// {
+namespace
+{
 
-// // creates a default edge of unit weight
-// inline InputEdge MakeUnitEdge(const NodeID from, const NodeID to)
-// {
-//     return {from,                          // source
-//             to,                            // target
-//             1,                             // weight
-//             1,                             // duration
-//             GeometryID{0, false},          // geometry_id
-//             false,                         // reversed
-//             NodeBasedEdgeClassification(), // default flags
-//             0};                            // AnnotationID
-// }
+// creates a default edge of unit weight
+inline InputEdge MakeUnitEdge(const NodeID from, const NodeID to)
+{
+    return {from,                          // source
+            to,                            // target
+            1,                             // weight
+            1,                             // duration
+            1,                             // distance
+            GeometryID{0, false},          // geometry_id
+            false,                         // reversed
+            NodeBasedEdgeClassification(), // default flags
+            0};                            // AnnotationID
+}
 
-// bool compatible(Graph const &graph,
-//                 const std::vector<NodeBasedEdgeAnnotation> &node_data_container,
-//                 EdgeID const first,
-//                 EdgeID second)
-// {
-//     auto const &first_flags = graph.GetEdgeData(first).flags;
-//     auto const &second_flags = graph.GetEdgeData(second).flags;
-//     if (!(first_flags == second_flags))
-//         return false;
+bool compatible(Graph const &graph,
+                const std::vector<NodeBasedEdgeAnnotation> &node_data_container,
+                EdgeID const first,
+                EdgeID second)
+{
+    auto const &first_flags = graph.GetEdgeData(first).flags;
+    auto const &second_flags = graph.GetEdgeData(second).flags;
+    if (!(first_flags == second_flags))
+        return false;
 
-//     if (graph.GetEdgeData(first).reversed != graph.GetEdgeData(second).reversed)
-//         return false;
+    if (graph.GetEdgeData(first).reversed != graph.GetEdgeData(second).reversed)
+        return false;
 
-//     auto const &first_annotation = node_data_container[graph.GetEdgeData(first).annotation_data];
-//     auto const &second_annotation =
-//     node_data_container[graph.GetEdgeData(second).annotation_data];
+    auto const &first_annotation = node_data_container[graph.GetEdgeData(first).annotation_data];
+    auto const &second_annotation = node_data_container[graph.GetEdgeData(second).annotation_data];
 
-//     return first_annotation.CanCombineWith(second_annotation);
-// }
+    return first_annotation.CanCombineWith(second_annotation);
+}
 
-// } // namespace
+} // namespace
 
-// BOOST_AUTO_TEST_CASE(long_road_test)
-// {
-//     //
-//     // 0---1---2---3---4
-//     //
-//     GraphCompressor compressor;
+BOOST_AUTO_TEST_CASE(long_road_test)
+{
+    //
+    // 0---1---2---3---4
+    //
+    GraphCompressor compressor;
 
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
-//                                     MakeUnitEdge(1, 0),
-//                                     MakeUnitEdge(1, 2),
-//                                     MakeUnitEdge(2, 1),
-//                                     MakeUnitEdge(2, 3),
-//                                     MakeUnitEdge(3, 2),
-//                                     MakeUnitEdge(3, 4),
-//                                     MakeUnitEdge(4, 3)};
+    std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
+                                    MakeUnitEdge(1, 0),
+                                    MakeUnitEdge(1, 2),
+                                    MakeUnitEdge(2, 1),
+                                    MakeUnitEdge(2, 3),
+                                    MakeUnitEdge(3, 2),
+                                    MakeUnitEdge(3, 4),
+                                    MakeUnitEdge(4, 3)};
 
-//     Graph graph(5, edges);
-//     BOOST_CHECK(compatible(graph, annotations, 0, 2));
-//     BOOST_CHECK(compatible(graph, annotations, 2, 4));
-//     BOOST_CHECK(compatible(graph, annotations, 4, 6));
+    Graph graph(5, edges);
+    BOOST_CHECK(compatible(graph, annotations, 0, 2));
+    BOOST_CHECK(compatible(graph, annotations, 2, 4));
+    BOOST_CHECK(compatible(graph, annotations, 4, 6));
 
-//     compressor.Compress(barrier_nodes,
-//                         traffic_lights,
-//                         scripting_environment,
-//                         restrictions,
-//                         conditional_restrictions,
-//                         maneuver_overrides,
-//                         graph,
-//                         annotations,
-//                         container);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(0, 1), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(1, 2), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(2, 3), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(3, 4), SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(0, 4) != SPECIAL_EDGEID);
-// }
+    compressor.Compress(barrier_nodes,
+                        traffic_lights,
+                        scripting_environment,
+                        restrictions,
+                        conditional_restrictions,
+                        maneuver_overrides,
+                        graph,
+                        annotations,
+                        container);
+    BOOST_CHECK_EQUAL(graph.FindEdge(0, 1), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(1, 2), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(2, 3), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(3, 4), SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(0, 4) != SPECIAL_EDGEID);
+}
 
-// BOOST_AUTO_TEST_CASE(loop_test)
-// {
-//     //
-//     // 0---1---2
-//     // |       |
-//     // 5---4---3
-//     //
-//     GraphCompressor compressor;
+BOOST_AUTO_TEST_CASE(loop_test)
+{
+    //
+    // 0---1---2
+    // |       |
+    // 5---4---3
+    //
+    GraphCompressor compressor;
 
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
-//                                     MakeUnitEdge(0, 5),
-//                                     MakeUnitEdge(1, 0),
-//                                     MakeUnitEdge(1, 2),
-//                                     MakeUnitEdge(2, 1),
-//                                     MakeUnitEdge(2, 3),
-//                                     MakeUnitEdge(3, 2),
-//                                     MakeUnitEdge(3, 4),
-//                                     MakeUnitEdge(4, 3),
-//                                     MakeUnitEdge(4, 5),
-//                                     MakeUnitEdge(5, 0),
-//                                     MakeUnitEdge(5, 4)};
+    std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
+                                    MakeUnitEdge(0, 5),
+                                    MakeUnitEdge(1, 0),
+                                    MakeUnitEdge(1, 2),
+                                    MakeUnitEdge(2, 1),
+                                    MakeUnitEdge(2, 3),
+                                    MakeUnitEdge(3, 2),
+                                    MakeUnitEdge(3, 4),
+                                    MakeUnitEdge(4, 3),
+                                    MakeUnitEdge(4, 5),
+                                    MakeUnitEdge(5, 0),
+                                    MakeUnitEdge(5, 4)};
 
-//     Graph graph(6, edges);
-//     BOOST_CHECK(edges.size() == 12);
-//     BOOST_CHECK(compatible(graph, annotations, 0, 1));
-//     BOOST_CHECK(compatible(graph, annotations, 1, 2));
-//     BOOST_CHECK(compatible(graph, annotations, 2, 3));
-//     BOOST_CHECK(compatible(graph, annotations, 3, 4));
-//     BOOST_CHECK(compatible(graph, annotations, 4, 5));
-//     BOOST_CHECK(compatible(graph, annotations, 5, 6));
-//     BOOST_CHECK(compatible(graph, annotations, 6, 7));
-//     BOOST_CHECK(compatible(graph, annotations, 7, 8));
-//     BOOST_CHECK(compatible(graph, annotations, 8, 9));
-//     BOOST_CHECK(compatible(graph, annotations, 9, 10));
-//     BOOST_CHECK(compatible(graph, annotations, 10, 11));
-//     BOOST_CHECK(compatible(graph, annotations, 11, 0));
+    Graph graph(6, edges);
+    BOOST_CHECK(edges.size() == 12);
+    BOOST_CHECK(compatible(graph, annotations, 0, 1));
+    BOOST_CHECK(compatible(graph, annotations, 1, 2));
+    BOOST_CHECK(compatible(graph, annotations, 2, 3));
+    BOOST_CHECK(compatible(graph, annotations, 3, 4));
+    BOOST_CHECK(compatible(graph, annotations, 4, 5));
+    BOOST_CHECK(compatible(graph, annotations, 5, 6));
+    BOOST_CHECK(compatible(graph, annotations, 6, 7));
+    BOOST_CHECK(compatible(graph, annotations, 7, 8));
+    BOOST_CHECK(compatible(graph, annotations, 8, 9));
+    BOOST_CHECK(compatible(graph, annotations, 9, 10));
+    BOOST_CHECK(compatible(graph, annotations, 10, 11));
+    BOOST_CHECK(compatible(graph, annotations, 11, 0));
 
-//     compressor.Compress(barrier_nodes,
-//                         traffic_lights,
-//                         scripting_environment,
-//                         restrictions,
-//                         conditional_restrictions,
-//                         maneuver_overrides,
-//                         graph,
-//                         annotations,
-//                         container);
+    compressor.Compress(barrier_nodes,
+                        traffic_lights,
+                        scripting_environment,
+                        restrictions,
+                        conditional_restrictions,
+                        maneuver_overrides,
+                        graph,
+                        annotations,
+                        container);
 
-//     BOOST_CHECK_EQUAL(graph.FindEdge(5, 0), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(0, 1), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(1, 2), SPECIAL_EDGEID);
-//     BOOST_CHECK_EQUAL(graph.FindEdge(2, 3), SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(5, 3) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(3, 4) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(4, 5) != SPECIAL_EDGEID);
-// }
+    BOOST_CHECK_EQUAL(graph.FindEdge(5, 0), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(0, 1), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(1, 2), SPECIAL_EDGEID);
+    BOOST_CHECK_EQUAL(graph.FindEdge(2, 3), SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(5, 3) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(3, 4) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(4, 5) != SPECIAL_EDGEID);
+}
 
-// BOOST_AUTO_TEST_CASE(t_intersection)
-// {
-//     //
-//     // 0---1---2
-//     //     |
-//     //     3
-//     //
-//     GraphCompressor compressor;
+BOOST_AUTO_TEST_CASE(t_intersection)
+{
+    //
+    // 0---1---2
+    //     |
+    //     3
+    //
+    GraphCompressor compressor;
 
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
-//                                     MakeUnitEdge(1, 0),
-//                                     MakeUnitEdge(1, 2),
-//                                     MakeUnitEdge(1, 3),
-//                                     MakeUnitEdge(2, 1),
-//                                     MakeUnitEdge(3, 1)};
+    std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
+                                    MakeUnitEdge(1, 0),
+                                    MakeUnitEdge(1, 2),
+                                    MakeUnitEdge(1, 3),
+                                    MakeUnitEdge(2, 1),
+                                    MakeUnitEdge(3, 1)};
 
-//     Graph graph(4, edges);
-//     BOOST_CHECK(compatible(graph, annotations, 0, 1));
-//     BOOST_CHECK(compatible(graph, annotations, 1, 2));
-//     BOOST_CHECK(compatible(graph, annotations, 2, 3));
-//     BOOST_CHECK(compatible(graph, annotations, 3, 4));
-//     BOOST_CHECK(compatible(graph, annotations, 4, 5));
+    Graph graph(4, edges);
+    BOOST_CHECK(compatible(graph, annotations, 0, 1));
+    BOOST_CHECK(compatible(graph, annotations, 1, 2));
+    BOOST_CHECK(compatible(graph, annotations, 2, 3));
+    BOOST_CHECK(compatible(graph, annotations, 3, 4));
+    BOOST_CHECK(compatible(graph, annotations, 4, 5));
 
-//     compressor.Compress(barrier_nodes,
-//                         traffic_lights,
-//                         scripting_environment,
-//                         restrictions,
-//                         conditional_restrictions,
-//                         maneuver_overrides,
-//                         graph,
-//                         annotations,
-//                         container);
+    compressor.Compress(barrier_nodes,
+                        traffic_lights,
+                        scripting_environment,
+                        restrictions,
+                        conditional_restrictions,
+                        maneuver_overrides,
+                        graph,
+                        annotations,
+                        container);
 
-//     BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(1, 3) != SPECIAL_EDGEID);
-// }
+    BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(1, 3) != SPECIAL_EDGEID);
+}
 
-// BOOST_AUTO_TEST_CASE(street_name_changes)
-// {
-//     //
-//     // 0---1---2
-//     //
-//     GraphCompressor compressor;
+BOOST_AUTO_TEST_CASE(street_name_changes)
+{
+    //
+    // 0---1---2
+    //
+    GraphCompressor compressor;
 
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<NodeBasedEdgeAnnotation> annotations(2);
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<NodeBasedEdgeAnnotation> annotations(2);
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     std::vector<InputEdge> edges = {
-//         MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
+    std::vector<InputEdge> edges = {
+        MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
 
-//     annotations[1].name_id = 1;
-//     edges[2].data.annotation_data = edges[3].data.annotation_data = 1;
+    annotations[1].name_id = 1;
+    edges[2].data.annotation_data = edges[3].data.annotation_data = 1;
 
-//     Graph graph(5, edges);
-//     BOOST_CHECK(compatible(graph, annotations, 0, 1));
-//     BOOST_CHECK(compatible(graph, annotations, 2, 3));
+    Graph graph(5, edges);
+    BOOST_CHECK(compatible(graph, annotations, 0, 1));
+    BOOST_CHECK(compatible(graph, annotations, 2, 3));
 
-//     compressor.Compress(barrier_nodes,
-//                         traffic_lights,
-//                         scripting_environment,
-//                         restrictions,
-//                         conditional_restrictions,
-//                         maneuver_overrides,
-//                         graph,
-//                         annotations,
-//                         container);
+    compressor.Compress(barrier_nodes,
+                        traffic_lights,
+                        scripting_environment,
+                        restrictions,
+                        conditional_restrictions,
+                        maneuver_overrides,
+                        graph,
+                        annotations,
+                        container);
 
-//     BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
-// }
+    BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
+}
 
-// BOOST_AUTO_TEST_CASE(direction_changes)
-// {
-//     //
-//     // 0-->1---2
-//     //
-//     GraphCompressor compressor;
+BOOST_AUTO_TEST_CASE(direction_changes)
+{
+    //
+    // 0-->1---2
+    //
+    GraphCompressor compressor;
 
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     std::vector<InputEdge> edges = {
-//         MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
-//     // make first edge point forward
-//     edges[1].data.reversed = true;
+    std::vector<InputEdge> edges = {
+        MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
+    // make first edge point forward
+    edges[1].data.reversed = true;
 
-//     Graph graph(5, edges);
-//     compressor.Compress(barrier_nodes,
-//                         traffic_lights,
-//                         scripting_environment,
-//                         restrictions,
-//                         conditional_restrictions,
-//                         maneuver_overrides,
-//                         graph,
-//                         annotations,
-//                         container);
+    Graph graph(5, edges);
+    compressor.Compress(barrier_nodes,
+                        traffic_lights,
+                        scripting_environment,
+                        restrictions,
+                        conditional_restrictions,
+                        maneuver_overrides,
+                        graph,
+                        annotations,
+                        container);
 
-//     BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-//     BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
-// }
+    BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
+}
 
-// BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()

unit_tests/extractor/intersection_analysis_tests.cpp

@@ -1,4 +1,4 @@
-// #include "extractor/intersection/intersection_analysis.hpp"
+#include "extractor/intersection/intersection_analysis.hpp"
 
 #include "extractor/graph_compressor.hpp"
 
@@ -17,306 +17,307 @@ using namespace osrm::extractor::intersection;
 using InputEdge = util::NodeBasedDynamicGraph::InputEdge;
 using Graph = util::NodeBasedDynamicGraph;
 
-// BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
-// {
-//     std::unordered_set<NodeID> barrier_nodes{6};
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<NodeBasedEdgeAnnotation> annotations{
-//         {EMPTY_NAMEID, 0, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false},
-//         {EMPTY_NAMEID, 1, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false}};
-//     std::vector<TurnRestriction> restrictions{TurnRestriction{NodeRestriction{0, 2, 1}, false}};
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
+{
+    std::unordered_set<NodeID> barrier_nodes{6};
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<NodeBasedEdgeAnnotation> annotations{
+        {EMPTY_NAMEID, 0, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false},
+        {EMPTY_NAMEID, 1, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false}};
+    std::vector<TurnRestriction> restrictions{TurnRestriction{NodeRestriction{0, 2, 1}, false}};
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     TurnLanesIndexedArray turn_lanes_data{{0, 0, 3},
-//                                           {TurnLaneType::uturn | TurnLaneType::left,
-//                                            TurnLaneType::straight,
-//                                            TurnLaneType::straight | TurnLaneType::right}};
+    TurnLanesIndexedArray turn_lanes_data{{0, 0, 3},
+                                          {TurnLaneType::uturn | TurnLaneType::left,
+                                           TurnLaneType::straight,
+                                           TurnLaneType::straight | TurnLaneType::right}};
 
-//     // Graph with an additional turn restriction 0→2→1 and bollard at 6
-//     //   0→5↔6↔7
-//     //   ↕
-//     // 1↔2←3
-//     //   ↓
-//     //   4
-//     const auto unit_edge =
-//         [](const NodeID from, const NodeID to, bool allowed, AnnotationID annotation) {
-//             return InputEdge{from,
-//                              to,
-//                              1,
-//                              1,
-//                              GeometryID{0, false},
-//                              !allowed,
-//                              NodeBasedEdgeClassification(),
-//                              annotation};
-//         };
+    // Graph with an additional turn restriction 0→2→1 and bollard at 6
+    //   0→5↔6↔7
+    //   ↕
+    // 1↔2←3
+    //   ↓
+    //   4
+    const auto unit_edge =
+        [](const NodeID from, const NodeID to, bool allowed, AnnotationID annotation) {
+            return InputEdge{from,
+                             to,
+                             1,
+                             1,
+                             1,
+                             GeometryID{0, false},
+                             !allowed,
+                             NodeBasedEdgeClassification(),
+                             annotation};
+        };
 
-//     std::vector<InputEdge> edges = {unit_edge(0, 2, true, 1),
-//                                     unit_edge(0, 5, true, 0),
-//                                     unit_edge(1, 2, true, 0),
-//                                     unit_edge(2, 0, true, 0),
-//                                     unit_edge(2, 1, true, 0),
-//                                     unit_edge(2, 3, false, 0),
-//                                     unit_edge(2, 4, true, 0),
-//                                     unit_edge(3, 2, true, 0),
-//                                     unit_edge(4, 2, false, 0),
-//                                     unit_edge(5, 0, false, 0),
-//                                     unit_edge(5, 6, true, 0),
-//                                     unit_edge(6, 5, true, 0),
-//                                     unit_edge(6, 7, true, 0),
-//                                     unit_edge(7, 6, true, 0)};
-//     IntersectionEdgeGeometries edge_geometries{
-//         {0, 180, 180, 10.},  // 0→2
-//         {1, 90, 90, 10.},    // 0→5
-//         {2, 90, 90, 10.},    // 1→2
-//         {3, 0, 0, 10.},      // 2→0
-//         {4, 270, 270, 10.},  // 2→1
-//         {5, 90, 90, 10.},    // 2→3
-//         {6, 180, 180, 10.},  // 2→4
-//         {7, 270, 270, 10.},  // 3→2
-//         {8, 0, 0, 10.},      // 4→2
-//         {9, 270, 270, 10.},  // 5→0
-//         {10, 90, 90, 10.},   // 5→6
-//         {11, 270, 270, 10.}, // 6→5
-//         {12, 90, 90, 10.},   // 6→7
-//         {13, 270, 270, 10.}  // 7→6
-//     };
+    std::vector<InputEdge> edges = {unit_edge(0, 2, true, 1),
+                                    unit_edge(0, 5, true, 0),
+                                    unit_edge(1, 2, true, 0),
+                                    unit_edge(2, 0, true, 0),
+                                    unit_edge(2, 1, true, 0),
+                                    unit_edge(2, 3, false, 0),
+                                    unit_edge(2, 4, true, 0),
+                                    unit_edge(3, 2, true, 0),
+                                    unit_edge(4, 2, false, 0),
+                                    unit_edge(5, 0, false, 0),
+                                    unit_edge(5, 6, true, 0),
+                                    unit_edge(6, 5, true, 0),
+                                    unit_edge(6, 7, true, 0),
+                                    unit_edge(7, 6, true, 0)};
+    IntersectionEdgeGeometries edge_geometries{
+        {0, 180, 180, 10.},  // 0→2
+        {1, 90, 90, 10.},    // 0→5
+        {2, 90, 90, 10.},    // 1→2
+        {3, 0, 0, 10.},      // 2→0
+        {4, 270, 270, 10.},  // 2→1
+        {5, 90, 90, 10.},    // 2→3
+        {6, 180, 180, 10.},  // 2→4
+        {7, 270, 270, 10.},  // 3→2
+        {8, 0, 0, 10.},      // 4→2
+        {9, 270, 270, 10.},  // 5→0
+        {10, 90, 90, 10.},   // 5→6
+        {11, 270, 270, 10.}, // 6→5
+        {12, 90, 90, 10.},   // 6→7
+        {13, 270, 270, 10.}  // 7→6
+    };
 
-//     Graph graph(8, edges);
+    Graph graph(8, edges);
 
-//     GraphCompressor().Compress(barrier_nodes,
-//                                traffic_lights,
-//                                scripting_environment,
-//                                restrictions,
-//                                conditional_restrictions,
-//                                maneuver_overrides,
-//                                graph,
-//                                annotations,
-//                                container);
+    GraphCompressor().Compress(barrier_nodes,
+                               traffic_lights,
+                               scripting_environment,
+                               restrictions,
+                               conditional_restrictions,
+                               maneuver_overrides,
+                               graph,
+                               annotations,
+                               container);
 
-//     REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 2), 3);
-//     REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 2), 4);
+    REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 2), 3);
+    REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 2), 4);
 
-//     EdgeBasedNodeDataContainer node_data_container(
-//         std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
-//     RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
+    EdgeBasedNodeDataContainer node_data_container(
+        std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
+    RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
 
-//     const auto connectivity_matrix = [&](NodeID node) {
-//         std::vector<bool> result;
-//         const auto incoming_edges = getIncomingEdges(graph, node);
-//         const auto outgoing_edges = getOutgoingEdges(graph, node);
-//         for (const auto incoming_edge : incoming_edges)
-//         {
-//             for (const auto outgoing_edge : outgoing_edges)
-//             {
-//                 result.push_back(isTurnAllowed(graph,
-//                                                node_data_container,
-//                                                restriction_map,
-//                                                barrier_nodes,
-//                                                edge_geometries,
-//                                                turn_lanes_data,
-//                                                incoming_edge,
-//                                                outgoing_edge));
-//             }
-//         }
-//         return result;
-//     };
+    const auto connectivity_matrix = [&](NodeID node) {
+        std::vector<bool> result;
+        const auto incoming_edges = getIncomingEdges(graph, node);
+        const auto outgoing_edges = getOutgoingEdges(graph, node);
+        for (const auto incoming_edge : incoming_edges)
+        {
+            for (const auto outgoing_edge : outgoing_edges)
+            {
+                result.push_back(isTurnAllowed(graph,
+                                               node_data_container,
+                                               restriction_map,
+                                               barrier_nodes,
+                                               edge_geometries,
+                                               turn_lanes_data,
+                                               incoming_edge,
+                                               outgoing_edge));
+            }
+        }
+        return result;
+    };
 
-//     CHECK_EQUAL_RANGE(connectivity_matrix(0), 1, 1); // from node 2 allowed U-turn and to node 5
-//     CHECK_EQUAL_RANGE(connectivity_matrix(1), 1);    // from node 2 allowed U-turn
-//     CHECK_EQUAL_RANGE(connectivity_matrix(2),
-//                       // clang-format off
-//                       1, 0, 0, 1, // from node 0 to node 4 and a U-turn at 2
-//                       1, 0, 0, 1, // from node 1 to nodes 0 and 4
-//                       1, 1, 0, 1  // from node 3 to nodes 0, 1 and 4
-//                       // clang-format on
-//                       );
-//     REQUIRE_SIZE_RANGE(connectivity_matrix(3), 0); // no incoming edges, empty matrix
-//     CHECK_EQUAL_RANGE(connectivity_matrix(4), 0);  // from node 2 not allowed U-turn
-//     CHECK_EQUAL_RANGE(connectivity_matrix(5),
-//                       // clang-format off
-//                       0, 1, // from node 0 to node 6
-//                       0, 1, // from node 6 a U-turn to node 6
-//                       // clang-format on
-//                       );
+    CHECK_EQUAL_RANGE(connectivity_matrix(0), 1, 1); // from node 2 allowed U-turn and to node 5
+    CHECK_EQUAL_RANGE(connectivity_matrix(1), 1);    // from node 2 allowed U-turn
+    CHECK_EQUAL_RANGE(connectivity_matrix(2),
+                      // clang-format off
+                      1, 0, 0, 1, // from node 0 to node 4 and a U-turn at 2
+                      1, 0, 0, 1, // from node 1 to nodes 0 and 4
+                      1, 1, 0, 1  // from node 3 to nodes 0, 1 and 4
+                      // clang-format on
+                      );
+    REQUIRE_SIZE_RANGE(connectivity_matrix(3), 0); // no incoming edges, empty matrix
+    CHECK_EQUAL_RANGE(connectivity_matrix(4), 0);  // from node 2 not allowed U-turn
+    CHECK_EQUAL_RANGE(connectivity_matrix(5),
+                      // clang-format off
+                      0, 1, // from node 0 to node 6
+                      0, 1, // from node 6 a U-turn to node 6
+                      // clang-format on
+                      );
 
-//     CHECK_EQUAL_RANGE(connectivity_matrix(6),
-//                       // clang-format off
-//                       1, 0, // from node 5 a U-turn to node 5
-//                       0, 1, // from node 7 a U-turn to node 7
-//                       // clang-format on
-//                       );
-// }
+    CHECK_EQUAL_RANGE(connectivity_matrix(6),
+                      // clang-format off
+                      1, 0, // from node 5 a U-turn to node 5
+                      0, 1, // from node 7 a U-turn to node 7
+                      // clang-format on
+                      );
+}
 
-// BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
-// {
-//     std::unordered_set<NodeID> barrier_nodes;
-//     std::unordered_set<NodeID> traffic_lights;
-//     std::vector<NodeBasedEdgeAnnotation> annotations;
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
+{
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+    std::vector<NodeBasedEdgeAnnotation> annotations;
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     TurnLanesIndexedArray turn_lanes_data;
+    TurnLanesIndexedArray turn_lanes_data;
 
-//     // Graph with roundabout edges 5→0→2
-//     //  1  2  3
-//     //   ↘ ↑ ↙
-//     //     0
-//     //   ↙ ↑ ↘
-//     //  4  5  6
-//     const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed, bool roundabout)
-//     {
-//         return InputEdge{from,
-//                          to,
-//                          1,
-//                          1,
-//                          GeometryID{0, false},
-//                          !allowed,
-//                          NodeBasedEdgeClassification{
-//                              true, false, false, roundabout, false, false, false, {}, 0, 0},
-//                          0};
-//     };
-//     std::vector<InputEdge> edges = {unit_edge(0, 1, false, false),
-//                                     unit_edge(0, 2, true, true),
-//                                     unit_edge(0, 3, false, false),
-//                                     unit_edge(0, 4, true, false),
-//                                     unit_edge(0, 5, false, true),
-//                                     unit_edge(0, 6, true, false),
-//                                     unit_edge(1, 0, true, false),
-//                                     unit_edge(2, 0, false, true),
-//                                     unit_edge(3, 0, true, false),
-//                                     unit_edge(4, 0, false, false),
-//                                     unit_edge(5, 0, true, true),
-//                                     unit_edge(6, 0, false, false)};
-//     IntersectionEdgeGeometries edge_geometries{
-//         {0, 315, 315, 10}, // 0→1
-//         {1, 0, 0, 10},     // 0→2
-//         {2, 45, 45, 10},   // 0→3
-//         {3, 225, 225, 10}, // 0→4
-//         {4, 180, 180, 10}, // 0→5
-//         {5, 135, 135, 10}, // 0→6
-//         {6, 135, 135, 10}, // 1→0
-//         {7, 180, 180, 10}, // 2→0
-//         {8, 225, 225, 10}, // 3→0
-//         {9, 45, 45, 10},   // 4→0
-//         {10, 0, 0, 10},    // 5→0
-//         {11, 315, 315, 10} // 6→0
-//     };
+    // Graph with roundabout edges 5→0→2
+    //  1  2  3
+    //   ↘ ↑ ↙
+    //     0
+    //   ↙ ↑ ↘
+    //  4  5  6
+    const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed, bool roundabout) {
+        return InputEdge{from,
+                         to,
+                         1,
+                         1,
+                         1,
+                         GeometryID{0, false},
+                         !allowed,
+                         NodeBasedEdgeClassification{
+                             true, false, false, roundabout, false, false, false, {}, 0, 0},
+                         0};
+    };
+    std::vector<InputEdge> edges = {unit_edge(0, 1, false, false),
+                                    unit_edge(0, 2, true, true),
+                                    unit_edge(0, 3, false, false),
+                                    unit_edge(0, 4, true, false),
+                                    unit_edge(0, 5, false, true),
+                                    unit_edge(0, 6, true, false),
+                                    unit_edge(1, 0, true, false),
+                                    unit_edge(2, 0, false, true),
+                                    unit_edge(3, 0, true, false),
+                                    unit_edge(4, 0, false, false),
+                                    unit_edge(5, 0, true, true),
+                                    unit_edge(6, 0, false, false)};
+    IntersectionEdgeGeometries edge_geometries{
+        {0, 315, 315, 10}, // 0→1
+        {1, 0, 0, 10},     // 0→2
+        {2, 45, 45, 10},   // 0→3
+        {3, 225, 225, 10}, // 0→4
+        {4, 180, 180, 10}, // 0→5
+        {5, 135, 135, 10}, // 0→6
+        {6, 135, 135, 10}, // 1→0
+        {7, 180, 180, 10}, // 2→0
+        {8, 225, 225, 10}, // 3→0
+        {9, 45, 45, 10},   // 4→0
+        {10, 0, 0, 10},    // 5→0
+        {11, 315, 315, 10} // 6→0
+    };
 
-//     Graph graph(7, edges);
+    Graph graph(7, edges);
 
-//     GraphCompressor().Compress(barrier_nodes,
-//                                traffic_lights,
-//                                scripting_environment,
-//                                restrictions,
-//                                conditional_restrictions,
-//                                maneuver_overrides,
-//                                graph,
-//                                annotations,
-//                                container);
+    GraphCompressor().Compress(barrier_nodes,
+                               traffic_lights,
+                               scripting_environment,
+                               restrictions,
+                               conditional_restrictions,
+                               maneuver_overrides,
+                               graph,
+                               annotations,
+                               container);
 
-//     REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 0), 3);
-//     REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 0), 6);
+    REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 0), 3);
+    REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 0), 6);
 
-//     EdgeBasedNodeDataContainer node_data_container(
-//         std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
-//     RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
+    EdgeBasedNodeDataContainer node_data_container(
+        std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
+    RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
 
-//     const auto connectivity_matrix = [&](NodeID node) {
-//         std::vector<bool> result;
-//         const auto incoming_edges = getIncomingEdges(graph, node);
-//         const auto outgoing_edges = getOutgoingEdges(graph, node);
-//         for (const auto incoming_edge : incoming_edges)
-//         {
-//             for (const auto outgoing_edge : outgoing_edges)
-//             {
-//                 result.push_back(isTurnAllowed(graph,
-//                                                node_data_container,
-//                                                restriction_map,
-//                                                barrier_nodes,
-//                                                edge_geometries,
-//                                                turn_lanes_data,
-//                                                incoming_edge,
-//                                                outgoing_edge));
-//             }
-//         }
-//         return result;
-//     };
+    const auto connectivity_matrix = [&](NodeID node) {
+        std::vector<bool> result;
+        const auto incoming_edges = getIncomingEdges(graph, node);
+        const auto outgoing_edges = getOutgoingEdges(graph, node);
+        for (const auto incoming_edge : incoming_edges)
+        {
+            for (const auto outgoing_edge : outgoing_edges)
+            {
+                result.push_back(isTurnAllowed(graph,
+                                               node_data_container,
+                                               restriction_map,
+                                               barrier_nodes,
+                                               edge_geometries,
+                                               turn_lanes_data,
+                                               incoming_edge,
+                                               outgoing_edge));
+            }
+        }
+        return result;
+    };
 
-//     CHECK_EQUAL_RANGE(connectivity_matrix(0),
-//                       // clang-format off
-//                       0, 1, 0, 0, 0, 1, // from node 1 to nodes 2 and 6
-//                       0, 1, 0, 1, 0, 0, // from node 3 to nodes 2 and 4
-//                       0, 1, 0, 1, 0, 1  // from node 5 to nodes 2, 4 and 6
-//                       // clang-format on
-//                       );
-// }
+    CHECK_EQUAL_RANGE(connectivity_matrix(0),
+                      // clang-format off
+                      0, 1, 0, 0, 0, 1, // from node 1 to nodes 2 and 6
+                      0, 1, 0, 1, 0, 0, // from node 3 to nodes 2 and 4
+                      0, 1, 0, 1, 0, 1  // from node 5 to nodes 2, 4 and 6
+                      // clang-format on
+                      );
+}
 
-// BOOST_AUTO_TEST_CASE(skip_degree_two_nodes)
-// {
-//     std::unordered_set<NodeID> barrier_nodes{1};
-//     std::unordered_set<NodeID> traffic_lights{2};
-//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-//     std::vector<TurnRestriction> restrictions;
-//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-//     CompressedEdgeContainer container;
-//     test::MockScriptingEnvironment scripting_environment;
-//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+BOOST_AUTO_TEST_CASE(skip_degree_two_nodes)
+{
+    std::unordered_set<NodeID> barrier_nodes{1};
+    std::unordered_set<NodeID> traffic_lights{2};
+    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+    std::vector<TurnRestriction> restrictions;
+    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+    CompressedEdgeContainer container;
+    test::MockScriptingEnvironment scripting_environment;
+    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-//     TurnLanesIndexedArray turn_lanes_data;
+    TurnLanesIndexedArray turn_lanes_data;
 
-//     // Graph
-//     //
-//     //  0↔1→2↔3↔4→5         7
-//     //          ↑          ↕ ↕
-//     //          6         8 ↔ 9
-//     //
-//     const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed) {
-//         return InputEdge{
-//             from, to, 1, 1, GeometryID{0, false}, !allowed, NodeBasedEdgeClassification{}, 0};
-//     };
-//     std::vector<InputEdge> edges = {unit_edge(0, 1, true), // 0
-//                                     unit_edge(1, 0, true),
-//                                     unit_edge(1, 2, true),
-//                                     unit_edge(2, 1, false),
-//                                     unit_edge(2, 3, true),
-//                                     unit_edge(3, 2, true), // 5
-//                                     unit_edge(3, 4, true),
-//                                     unit_edge(4, 3, true),
-//                                     unit_edge(4, 5, true),
-//                                     unit_edge(4, 6, false),
-//                                     unit_edge(5, 4, false), // 10
-//                                     unit_edge(6, 4, true),
-//                                     // Circle
-//                                     unit_edge(7, 8, true), // 12
-//                                     unit_edge(7, 9, true),
-//                                     unit_edge(8, 7, true),
-//                                     unit_edge(8, 9, true),
-//                                     unit_edge(9, 7, true),
-//                                     unit_edge(9, 8, true)};
+    // Graph
+    //
+    //  0↔1→2↔3↔4→5         7
+    //          ↑          ↕ ↕
+    //          6         8 ↔ 9
+    //
+    const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed) {
+        return InputEdge{
+            from, to, 1, 1, 1, GeometryID{0, false}, !allowed, NodeBasedEdgeClassification{}, 0};
+    };
+    std::vector<InputEdge> edges = {unit_edge(0, 1, true), // 0
+                                    unit_edge(1, 0, true),
+                                    unit_edge(1, 2, true),
+                                    unit_edge(2, 1, false),
+                                    unit_edge(2, 3, true),
+                                    unit_edge(3, 2, true), // 5
+                                    unit_edge(3, 4, true),
+                                    unit_edge(4, 3, true),
+                                    unit_edge(4, 5, true),
+                                    unit_edge(4, 6, false),
+                                    unit_edge(5, 4, false), // 10
+                                    unit_edge(6, 4, true),
+                                    // Circle
+                                    unit_edge(7, 8, true), // 12
+                                    unit_edge(7, 9, true),
+                                    unit_edge(8, 7, true),
+                                    unit_edge(8, 9, true),
+                                    unit_edge(9, 7, true),
+                                    unit_edge(9, 8, true)};
 
-//     Graph graph(10, edges);
+    Graph graph(10, edges);
 
-//     GraphCompressor().Compress(barrier_nodes,
-//                                traffic_lights,
-//                                scripting_environment,
-//                                restrictions,
-//                                conditional_restrictions,
-//                                maneuver_overrides,
-//                                graph,
-//                                annotations,
-//                                container);
+    GraphCompressor().Compress(barrier_nodes,
+                               traffic_lights,
+                               scripting_environment,
+                               restrictions,
+                               conditional_restrictions,
+                               maneuver_overrides,
+                               graph,
+                               annotations,
+                               container);
 
-//     BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {0, 0}).edge), 4);
-//     BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {4, 7}).edge), 0);
-//     BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {5, 10}).edge), 4);
-//     BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {6, 11}).edge), 4);
-//     BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {7, 12}).edge), 7);
-// }
+    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {0, 0}).edge), 4);
+    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {4, 7}).edge), 0);
+    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {5, 10}).edge), 4);
+    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {6, 11}).edge), 4);
+    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {7, 12}).edge), 7);
+}
 
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/library/extract.cpp

@@ -16,13 +16,13 @@ BOOST_AUTO_TEST_CASE(test_extract_with_invalid_config)
                       std::exception); // including osrm::util::exception, osmium::io_error, etc.
 }
 
-// BOOST_AUTO_TEST_CASE(test_extract_with_valid_config)
-// {
-//     osrm::ExtractorConfig config;
-//     config.input_path = OSRM_TEST_DATA_DIR "/monaco.osm.pbf";
-//     config.UseDefaultOutputNames(OSRM_TEST_DATA_DIR "/monaco.osm.pbf");
-//     config.requested_num_threads = tbb::task_scheduler_init::default_num_threads();
-//     BOOST_CHECK_NO_THROW(osrm::extract(config));
-// }
+BOOST_AUTO_TEST_CASE(test_extract_with_valid_config)
+{
+    osrm::ExtractorConfig config;
+    config.input_path = OSRM_TEST_DATA_DIR "/monaco.osm.pbf";
+    config.UseDefaultOutputNames(OSRM_TEST_DATA_DIR "/monaco.osm.pbf");
+    config.requested_num_threads = tbb::task_scheduler_init::default_num_threads();
+    BOOST_CHECK_NO_THROW(osrm::extract(config));
+}
 
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/server/parameters_parser.cpp

@@ -507,7 +507,7 @@ BOOST_AUTO_TEST_CASE(valid_table_urls)
 
     std::vector<std::size_t> sources_2 = {1, 2, 3};
     std::vector<std::size_t> destinations_2 = {4, 5};
-    TableParameters reference_2{sources_2, destinations_2};
+    TableParameters reference_2{sources_2, destinations_2, 0};
     reference_2.coordinates = coords_1;
     auto result_2 = parseParameters<TableParameters>("1,2;3,4?sources=1;2;3&destinations=4;5");
     BOOST_CHECK(result_2);

unit_tests/storage/data_layout.cpp

@@ -15,7 +15,7 @@ using namespace osrm::storage;
 
 BOOST_AUTO_TEST_CASE(layout_write_test)
 {
-    std::unique_ptr<BaseDataLayout> layout = std::make_unique<DataLayout>();
+    std::unique_ptr<BaseDataLayout> layout = std::make_unique<ContiguousDataLayout>();
 
     Block block_1{20, 8 * 20};
     Block block_2{1, 4 * 1};
@@ -68,7 +68,7 @@ BOOST_AUTO_TEST_CASE(layout_write_test)
 
 BOOST_AUTO_TEST_CASE(layout_list_test)
 {
-    std::unique_ptr<BaseDataLayout> layout = std::make_unique<DataLayout>();
+    std::unique_ptr<BaseDataLayout> layout = std::make_unique<ContiguousDataLayout>();
 
     Block block_1{20, 8 * 20};
     Block block_2{1, 4 * 1};

unit_tests/storage/serialization.cpp

@@ -1,11 +1,15 @@
 #include "storage/serialization.hpp"
 
+#include "util/vector_view.hpp"
+
 #include "../common/range_tools.hpp"
 #include "../common/temporary_file.hpp"
 
 #include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include <random>
+
 BOOST_AUTO_TEST_SUITE(serialization)
 
 using namespace osrm;
@@ -15,20 +19,48 @@ BOOST_AUTO_TEST_CASE(pack_test)
 {
     std::vector<bool> v = {0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1};
 
-    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 0, 8), 0x2e);
-    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 5, 7), 0x65);
-    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 6, 8), 0x95);
+    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 0, 8), 0x74);
+    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 5, 7), 0x53);
+    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 6, 8), 0xa9);
     BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 11, 1), 0x01);
 }
 
+BOOST_AUTO_TEST_CASE(vector_view_pack_test)
+{
+    // Verifies that the packing generated by packBits matches
+    // what vector_view<bool> expects
+
+    // 1. Generate a random bool vector that covers several uint64_t bytes
+    constexpr unsigned RANDOM_SEED = 42;
+    std::mt19937 g(RANDOM_SEED);
+    std::uniform_int_distribution<> binary_distribution(0, 1);
+    std::vector<bool> v(150);
+    for (std::size_t i = 0; i < v.size(); ++i)
+        v[i] = binary_distribution(g) == 1;
+
+    // 2. Pack the vector into a contiguous set of bytes
+    std::uint64_t data[3];
+    data[0] = storage::serialization::detail::packBits<decltype(v), std::uint64_t>(v, 0, 64);
+    data[1] = storage::serialization::detail::packBits<decltype(v), std::uint64_t>(v, 64, 64);
+    data[2] = storage::serialization::detail::packBits<decltype(v), std::uint64_t>(v, 128, 22);
+
+    // 3. Make a vector_view of that memory, and see if the bit sequence is
+    //    interpreted correctly by vector_view
+    util::vector_view<bool> view(data, v.size());
+    for (std::size_t index = 0; index < v.size(); ++index)
+    {
+        BOOST_CHECK_EQUAL(v[index], view[index]);
+    }
+}
+
 BOOST_AUTO_TEST_CASE(unpack_test)
 {
     std::vector<bool> v(14), expected = {0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1};
 
-    storage::serialization::detail::unpackBits(v, 0, 8, 0x2e);
-    storage::serialization::detail::unpackBits(v, 5, 7, 0x65);
-    storage::serialization::detail::unpackBits(v, 6, 8, 0x95);
-    storage::serialization::detail::unpackBits(v, 11, 1, 0x01);
+    storage::serialization::detail::unpackBits(v, 0, 8, 0x74u);
+    storage::serialization::detail::unpackBits(v, 5, 7, 0x53u);
+    storage::serialization::detail::unpackBits(v, 6, 8, 0xa9u);
+    storage::serialization::detail::unpackBits(v, 11, 1, 0x01u);
     BOOST_CHECK_EQUAL_COLLECTIONS(v.begin(), v.end(), expected.begin(), expected.end());
 }
 

unit_tests/updater/timezoner.cpp

@@ -12,50 +12,46 @@ using namespace osrm::updater;
 
 BOOST_AUTO_TEST_CASE(timezoner_test)
 {
-    // const char json[] =
-    //     "{ \"type\" : \"FeatureCollection\", \"features\": ["
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
-    // std::time_t now = time(0);
-    // BOOST_CHECK_NO_THROW(Timezoner tz(json, now));
+    const char json[] =
+        "{ \"type\" : \"FeatureCollection\", \"features\": ["
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    std::time_t now = time(0);
+    BOOST_CHECK_NO_THROW(Timezoner tz(json, now));
 
-    // boost::filesystem::path test_path(TEST_DATA_DIR "/test.geojson");
-    // BOOST_CHECK_NO_THROW(Timezoner tz(test_path, now));
+    boost::filesystem::path test_path(TEST_DATA_DIR "/test.geojson");
+    BOOST_CHECK_NO_THROW(Timezoner tz(test_path, now));
 
     // missing opening bracket
-    // const char bad[] =
-    //     "\"type\" : \"FeatureCollection\", \"features\": ["
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
-    // BOOST_CHECK_THROW(Timezoner tz(bad, now), util::exception);
+    const char bad[] =
+        "\"type\" : \"FeatureCollection\", \"features\": ["
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    BOOST_CHECK_THROW(Timezoner tz(bad, now), util::exception);
 
     // missing/malformed FeatureCollection type field
-    // const char missing_type[] =
-    //     "{ \"FeatureCollection\", \"features\": ["
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
-    // BOOST_CHECK_THROW(Timezoner tz(missing_type, now), util::exception);
+    const char missing_type[] =
+        "{ \"FeatureCollection\", \"features\": ["
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    BOOST_CHECK_THROW(Timezoner tz(missing_type, now), util::exception);
 
-    // const char missing_featc[] =
-    //     "{ \"type\" : \"Collection\", \"features\": ["
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
-    // BOOST_CHECK_THROW(Timezoner tz(missing_featc, now), util::exception);
+    const char missing_featc[] =
+        "{ \"type\" : \"Collection\", \"features\": ["
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    BOOST_CHECK_THROW(Timezoner tz(missing_featc, now), util::exception);
 }
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/updater/validation.cpp

@@ -71,74 +71,68 @@ BOOST_AUTO_TEST_CASE(timezone_validation_test)
                           "48.88277], [8.57757, 49.07206], [8.28369, "
                           "49.07206], [8.28369, 48.88277]]] }}";
     doc.Parse(missing_tzid);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char tzid_err[] = "{ \"type\" : \"Feature\","
-    //                   "\"properties\" : { \"TZID\" : []}, \"geometry\" : { \"type\": \"polygon\",
-    //                   "
-    //                   "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //                   "48.88277], [8.57757, 49.07206], [8.28369, "
-    //                   "49.07206], [8.28369, 48.88277]]] }}";
-    // doc.Parse(tzid_err);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char tzid_err[] = "{ \"type\" : \"Feature\","
+                      "\"properties\" : { \"TZID\" : []}, \"geometry\" : { \"type\": \"polygon\", "
+                      "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+                      "48.88277], [8.57757, 49.07206], [8.28369, "
+                      "49.07206], [8.28369, 48.88277]]] }}";
+    doc.Parse(tzid_err);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char missing_geom[] = "{ \"type\" : \"Feature\","
-    //                       "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometries\" : { "
-    //                       "\"type\": \"polygon\", "
-    //                       "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //                       "48.88277], [8.57757, 49.07206], [8.28369, "
-    //                       "49.07206], [8.28369, 48.88277]]] }}";
-    // doc.Parse(missing_geom);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char missing_geom[] = "{ \"type\" : \"Feature\","
+                          "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometries\" : { "
+                          "\"type\": \"polygon\", "
+                          "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+                          "48.88277], [8.57757, 49.07206], [8.28369, "
+                          "49.07206], [8.28369, 48.88277]]] }}";
+    doc.Parse(missing_geom);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char nonobj_geom[] =
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : [ \"type\",
-    //     \"polygon\", "
-    //     "\"coordinates\", [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] ]}";
-    // doc.Parse(nonobj_geom);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char nonobj_geom[] =
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : [ \"type\", \"polygon\", "
+        "\"coordinates\", [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] ]}";
+    doc.Parse(nonobj_geom);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char missing_geom_type[] = "{ \"type\" : \"Feature\","
-    //                            "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" :
-    //                            { "
-    //                            "\"no_type\": \"polygon\", "
-    //                            "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //                            "48.88277], [8.57757, 49.07206], [8.28369, "
-    //                            "49.07206], [8.28369, 48.88277]]] }}";
-    // doc.Parse(missing_geom_type);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char missing_geom_type[] = "{ \"type\" : \"Feature\","
+                               "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { "
+                               "\"no_type\": \"polygon\", "
+                               "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+                               "48.88277], [8.57757, 49.07206], [8.28369, "
+                               "49.07206], [8.28369, 48.88277]]] }}";
+    doc.Parse(missing_geom_type);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char nonstring_geom_type[] = "{ \"type\" : \"Feature\","
-    //                              "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\"
-    //                              : "
-    //                              "{ \"type\": [\"polygon\"], "
-    //                              "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-    //                              "48.88277], [8.57757, 49.07206], [8.28369, "
-    //                              "49.07206], [8.28369, 48.88277]]] }}";
-    // doc.Parse(nonstring_geom_type);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char nonstring_geom_type[] = "{ \"type\" : \"Feature\","
+                                 "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : "
+                                 "{ \"type\": [\"polygon\"], "
+                                 "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+                                 "48.88277], [8.57757, 49.07206], [8.28369, "
+                                 "49.07206], [8.28369, 48.88277]]] }}";
+    doc.Parse(nonstring_geom_type);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char missing_coords[] =
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coords\": [[[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]]] }}";
-    // doc.Parse(missing_coords);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char missing_coords[] =
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coords\": [[[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]]] }}";
+    doc.Parse(missing_coords);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    // char missing_outerring[] =
-    //     "{ \"type\" : \"Feature\","
-    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-    //     \"polygon\", "
-    //     "\"coordinates\": [[8.28369,48.88277], [8.57757, "
-    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    //     "49.07206], [8.28369, 48.88277]] }}";
-    // doc.Parse(missing_outerring);
-    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    char missing_outerring[] =
+        "{ \"type\" : \"Feature\","
+        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+        "\"coordinates\": [[8.28369,48.88277], [8.57757, "
+        "48.88277], [8.57757, 49.07206], [8.28369, "
+        "49.07206], [8.28369, 48.88277]] }}";
+    doc.Parse(missing_outerring);
+    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 }
 BOOST_AUTO_TEST_SUITE_END()