Bump to 5.20.0-alpha.4

This reverts commit ddb25cdf22.

.travis.yml

@@ -13,7 +13,6 @@ notifications:
 branches:
   only:
     - master
-    - "5.20"
     # enable building tags
     - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
 
@@ -155,14 +154,6 @@ matrix:
           packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev', 'ccache']
       env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release'
 
-    - os: osx
-      osx_image: xcode9.2
-      compiler: "mason-osx-release-node-10"
-      # we use the xcode provides clang and don't install our own
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="10"
-      after_success:
-        - ./scripts/travis/publish.sh
-
     - os: osx
       osx_image: xcode9.2
       compiler: "mason-osx-release-node-8"
@@ -285,54 +276,6 @@ matrix:
       after_success:
         - ./scripts/travis/publish.sh
 
-    - os: linux
-      sudo: false
-      compiler: "node-10-mason-linux-release"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="10"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-10-mason-linux-debug"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="10"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
 before_install:
   - source $NVM_DIR/nvm.sh
   - nvm install $NODE
@@ -353,7 +296,7 @@ before_install:
     fi
   - |
     if [[ ! -f $(which yarn) ]]; then
-      npm install -g yarn@1.11.1
+      npm install -g yarn
     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")
@@ -422,7 +365,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,28 +1,14 @@
-# 5.20.0
+# 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)
-      - ADDED: new parameter `fallback_speed` which will fill `null` cells with estimated value [#5257](https://github.com/Project-OSRM/osrm-backend/pull/5257)
-      - CHANGED: Remove API check for matrix sources/destination length to be less than or equal to coordinates length. [#5298](https://github.com/Project-OSRM/osrm-backend/pull/5289)
-      - FIXED: Fix crashing bug when using fallback_speed parameter with more sources than destinations. [#5291](https://github.com/Project-OSRM/osrm-backend/pull/5291)
     - 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)
-      - ADDED: Now publishing Node 10.x LTS binary modules [#5246](https://github.com/Project-OSRM/osrm-backend/pull/5246)
-    - 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/http.md

@@ -236,9 +236,8 @@ In addition to the [general options](#general-options) the following options are
 |------------|--------------------------------------------------|---------------------------------------------|
 |sources     |`{index};{index}[;{index} ...]` or `all` (default)|Use location with given index as source.     |
 |destinations|`{index};{index}[;{index} ...]` or `all` (default)|Use location with given index as destination.|
-|annotations |`duration` (default), `distance`, or `duration,distance`|Return the requested table or tables in response. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned. |
+|annotations |`duration` (default), `distance`, or `duration,distance`|Return the requested table or tables in response. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
-|fallback_speed|`double > 0`|If no route found between a source/destination pair, calculate the as-the-crow-flies distance, then use this speed to estimate duration.|
+|
-|fallback_coordinate|`input` (default), or `snapped`| When using a `fallback_speed`, use the user-supplied coordinate (`input`), or the snapped location (`snapped`) for calculating distances.|
 
 Unlike other array encoded options, the length of `sources` and `destinations` can be **smaller or equal**
 to number of input locations;

docs/nodejs/api.md

@@ -25,9 +25,7 @@ var osrm = new OSRM('network.osrm');
                Make sure you prepared the dataset with the correct toolchain.
     -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
                This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
-    -   `options.memory_file` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** *DEPRECATED*
+    -   `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.
-               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).
@@ -58,7 +56,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**
 
@@ -90,7 +88,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**
 
@@ -129,9 +127,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`.
-    -   `options.fallback_speed` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Replace `null` responses in result with as-the-crow-flies estimates based on `fallback_speed`.  Value is in metres/second.
+-   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
-    -   `options.fallback_coordinate` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Either `input` (default) or `snapped`.  If using a `fallback_speed`, use either the user-supplied coordinate (`input`), or the snapped coordinate (`snapped`) for calculating the as-the-crow-flies diestance between two points.
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
 
@@ -171,7 +167,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**
 
@@ -208,7 +204,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**
 
@@ -272,7 +268,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**
 
@@ -326,14 +322,16 @@ osrm.route(options, { format: "json_buffer" }, function(err, response) {
 
 ## Responses
 
+Responses
+
 ### Route
 
 Represents a route through (potentially multiple) waypoints.
 
 **Parameters**
 
--   **documentation** in
+-   `exteral` **documentation** in
-    [`osrm-backend`](../http.md#route-object)
+    [`osrm-backend`](../http.md#route)
 
 ### RouteLeg
 
@@ -341,8 +339,8 @@ Represents a route between two waypoints.
 
 **Parameters**
 
--   **documentation** in
+-   `exteral` **documentation** in
-    [`osrm-backend`](../http.md#routeleg-object)
+    [`osrm-backend`](../http.md#routeleg)
 
 ### RouteStep
 
@@ -351,15 +349,15 @@ single way to the subsequent step.
 
 **Parameters**
 
--   **documentation** in
+-   `exteral` **documentation** in
-    [`osrm-backend`](../http.md#routestep-object)
+    [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#routestep)
 
 ### StepManeuver
 
 **Parameters**
 
--   **documentation** in
+-   `exteral` **documentation** in
-    [`osrm-backend`](../http.md#stepmaneuver-object)
+    [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#stepmaneuver)
 
 ### Waypoint
 
@@ -367,5 +365,5 @@ Object used to describe waypoint on a route.
 
 **Parameters**
 
--   **documentation** in
+-   `exteral` **documentation** in
-    [`osrm-backend`](../http.md#waypoint-object)
+    [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#waypoint)

features/support/env.js

@@ -80,7 +80,7 @@ module.exports = function () {
 
         // eslint-disable-next-line no-console
         console.info(util.format('Node Version', process.version));
-        if (parseInt(process.version.match(/v(\d+)/)[1]) < 4) throw new Error('*** Please upgrade to Node 4.+ to run OSRM cucumber tests');
+        if (parseInt(process.version.match(/v(\d)/)[1]) < 4) throw new Error('*** Please upgrade to Node 4.+ to run OSRM cucumber tests');
 
         fs.exists(this.TEST_PATH, (exists) => {
             if (exists)

features/testbot/distance_matrix.feature

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

features/testbot/duration_matrix.feature

@@ -510,74 +510,3 @@ Feature: Basic Duration Matrix
             |   |   a   |
             | a |   0   |
             | b | 24.1  |
-
-    Scenario: Testbot - Filling in noroutes with estimates (defaults to input coordinate location)
-        Given a grid size of 300 meters
-        Given the extract extra arguments "--small-component-size 4"
-        Given the query options
-            | fallback_speed | 5 |
-        Given the node map
-            """
-            a b   f h 1
-            d e   g i
-            """
-
-        And the ways
-            | nodes |
-            | abeda |
-            | fhigf |
-
-        When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 30 | 18 | 30 |
-            | b | 30 | 0  | 12 | 24 |
-            | f | 18 | 12 | 0  | 30 |
-            | 1 | 30 | 24 | 30 | 0  |
-
-    Scenario: Testbot - Filling in noroutes with estimates - use input coordinate
-        Given a grid size of 300 meters
-        Given the extract extra arguments "--small-component-size 4"
-        Given the query options
-            | fallback_speed | 5 |
-            | fallback_coordinate | input |
-        Given the node map
-            """
-            a b   f h 1
-            d e   g i
-            """
-
-        And the ways
-            | nodes |
-            | abeda |
-            | fhigf |
-
-        When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 30 | 18 | 30 |
-            | b | 30 | 0  | 12 | 24 |
-            | f | 18 | 12 | 0  | 30 |
-            | 1 | 30 | 24 | 30 | 0  |
-
-    Scenario: Testbot - Filling in noroutes with estimates - use snapped coordinate
-        Given a grid size of 300 meters
-        Given the extract extra arguments "--small-component-size 4"
-        Given the query options
-            | fallback_speed | 5 |
-            | fallback_coordinate | snapped |
-        Given the node map
-            """
-            a b   f h 1
-            d e   g i
-            """
-
-        And the ways
-            | nodes |
-            | abeda |
-            | fhigf |
-
-        When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 30 | 18 | 24 |
-            | b | 30 | 0  | 12 | 18 |
-            | f | 18 | 12 | 0  | 30 |
-            | 1 | 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,76 +67,78 @@ Feature: Multi level routing
 
         When I route I should get
             | from | to | route                                  | time   |
-            | a    | b  | abcda,abcda                            | 25s    |
+            | a    | b  | abcda,abcda                            | 20s    |
-            | a    | f  | abcda,cm,mnopm,kp,ijkli,hj,efghe,efghe | 239.2s |
+            | a    | f  | abcda,cm,mnopm,kp,ijkli,hj,efghe,efghe | 229.4s |
-            | a    | l  | abcda,cm,mnopm,kp,ijkli,ijkli          | 157.1s |
+            | a    | l  | abcda,cm,mnopm,kp,ijkli,ijkli          | 144.7s |
-            | a    | o  | abcda,cm,mnopm,mnopm,mnopm             | 137.1s |
+            | a    | o  | abcda,cm,mnopm,mnopm,mnopm             | 124.7s |
-            | f    | l  | efghe,hj,ijkli,ijkli                   | 136.7s |
+            | f    | l  | efghe,hj,ijkli,ijkli,ijkli             | 124.7s |
-            | f    | o  | efghe,hj,ijkli,kp,mnopm,mnopm          | 162.1s |
+            | f    | o  | efghe,hj,ijkli,kp,mnopm,mnopm          | 144.7s |
-            | l    | o  | ijkli,kp,mnopm,mnopm                   | 80s    |
+            | l    | o  | ijkli,kp,mnopm,mnopm                   | 60s    |
             | 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 |     f |     l |     o |
-            | a | 0     | 239.2 | 157.1 | 137.1 |
+            | a |     0 | 229.4 | 144.7 | 124.7 |
-            | f | 239.2 | 0     | 136.7 | 162.1 |
+            | f | 229.4 |     0 | 124.7 | 144.7 |
-            | l | 157.1 | 136.7 | 0     | 80    |
+            | l | 144.7 | 124.7 |     0 |    60 |
-            | o | 137.1 | 162.1 | 80    | 0     |
+            | o | 124.7 | 144.7 |    60 |     0 |
 
         When I request a travel time matrix I should get
-            |   | a | f     | l     | o     |
+            |   |     a |     f |     l |     o |
-            | a | 0 | 239.2 | 157.1 | 137.1 |
+            | a |     0 | 229.4 | 144.7 | 124.7 |
 
         When I request a travel time matrix I should get
-            |   |   a   |
+            |   |     a |
-            | a |   0   |
+            | a |     0 |
-            | f | 239.2 |
+            | f | 229.4 |
-            | l | 157.1 |
+            | l | 144.7 |
-            | o | 137.1 |
+            | o | 124.7 |
 
         When I request a travel time matrix I should get
-            |   | a     | f     | l     | o     |
+            |   |     a |     f |     l |     o |
-            | a | 0     | 239.2 | 157.1 | 137.1 |
+            | a |     0 | 229.4 | 144.7 | 124.7 |
-            | o | 137.1 | 162.1 | 80    | 0     |
+            | o | 124.7 | 144.7 |    60 |     0 |
 
         When I request a travel time matrix I should get
             |   |     a |     o |
-            | a |     0 | 137.1 |
+            | a |     0 | 124.7 |
-            | f | 239.2 | 162.1 |
+            | f | 229.4 | 144.7 |
-            | l | 157.1 |    80 |
+            | l | 144.7 |    60 |
-            | o | 137.1 |     0 |
+            | o | 124.7 |     0 |
+
 
         When I request a travel distance matrix I should get
-            |   | a      | f      | l      | o      |
+            |   |       a |       f |       l |         o |
-            | a | 0      | 2383.7 | 1566.9 | 1366.8 |
+            | a |    0+-2 | 2287+-2 | 1443+-2 |   1243+-2 |
-            | f | 2339.9 | 0      | 1198.1 | 1522.1 |
+            | f | 2284+-2 |    0+-2 | 1241+-2 |   1443+-2 |
-            | l | 1618.3 | 1293.3 | 0      | 800.5  |
+            | l | 1443+-2 | 1244+-2 |    0+-2 |    600+-2 |
-            | o | 1418.2 | 1617.3 | 800.5  | 0      |
+            | o | 1243+-2 | 1444+-2 |  600+-2 |      0+-2 |
 
         When I request a travel distance matrix I should get
-            |   | a | f      | l      | o      |
+            |   | a | f          | l          | o        |
-            | a | 0 | 2383.7 | 1566.9 | 1366.8 |
+            | a | 0 | 2287.2+-2  | 1443+-2    | 1243+-2  |
 
         When I request a travel distance matrix I should get
-            |   | a      |
+            |   |         a |
-            | a | 0      |
+            | a |         0 |
-            | f | 2339.9 |
+            | f | 2284.5+-2 |
-            | l | 1618.3 |
+            | l |    1443.1 |
-            | o | 1418.2 |
+            | o |      1243 |
 
         When I request a travel distance matrix I should get
-            |   | a      | f      | l      | o      |
+            |   |    a |      f  |      l  |       o |
-            | a | 0      | 2383.7 | 1566.9 | 1366.8 |
+            | a |    0 | 2287+-2 | 1443+-2 | 1243+-2 |
-            | f | 2339.9 | 0      | 1198.1 | 1522.1 |
+            | o | 1243 | 1444+-2 |  600+-2 |    0+-2 |
+
 
         When I request a travel distance matrix I should get
-            |   | a      | o      |
+            |   |         a |        o  |
-            | a | 0      | 1366.8 |
+            | a |      0+-2 |   1243+-2 |
-            | f | 2339.9 | 1522.1 |
+            | f |   2284+-2 |   1443+-2 |
-            | l | 1618.3 | 800.5  |
+            | l |   1443+-2 |    600+-2 |
-            | o | 1418.2 | 0      |
+            | o |   1243+-2 |      0+-2 |
+
+
 
     Scenario: Testbot - Multi level routing: horizontal road
         Given the node map

include/contractor/contractor_config.hpp

@@ -72,8 +72,14 @@ 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,7 +22,6 @@ class CellCustomizer
     {
         bool from_clique;
         EdgeDuration duration;
-        EdgeDistance distance;
     };
 
   public:
@@ -61,7 +60,7 @@ class CellCustomizer
                 }
             }
             heap.Clear();
-            heap.Insert(source, 0, {false, 0, 0});
+            heap.Insert(source, 0, {false, 0});
 
             // explore search space
             while (!heap.Empty() && !destinations_set.empty())
@@ -69,18 +68,8 @@ 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,
+                RelaxNode(graph, cells, allowed_nodes, metric, heap, level, node, weight, duration);
-                          cells,
-                          allowed_nodes,
-                          metric,
-                          heap,
-                          level,
-                          node,
-                          weight,
-                          duration,
-                          distance);
 
                 destinations_set.erase(node);
             }
@@ -88,27 +77,21 @@ 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());
         }
     }
 
@@ -145,8 +128,7 @@ class CellCustomizer
                    LevelID level,
                    NodeID node,
                    EdgeWeight weight,
-                   EdgeDuration duration,
+                   EdgeDuration duration) const
-                   EdgeDistance distance) const
     {
         auto first_level = level == 1;
         BOOST_ASSERT(heap.WasInserted(node));
@@ -167,7 +149,6 @@ 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)
@@ -180,24 +161,20 @@ 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, to_distance});
+                            heap.Insert(to, to_weight, {true, to_duration});
                         }
-                        else if (std::tie(to_weight, to_duration, to_distance) <
+                        else if (std::tie(to_weight, to_duration) <
-                                 std::tie(heap.GetKey(to),
+                                 std::tie(heap.GetKey(to), heap.GetData(to).duration))
-                                          heap.GetData(to).duration,
-                                          heap.GetData(to).distance))
                         {
                             heap.DecreaseKey(to, to_weight);
-                            heap.GetData(to) = {true, to_duration, to_distance};
+                            heap.GetData(to) = {true, to_duration};
                         }
                     }
 
                     ++subcell_destination;
                     ++subcell_duration;
-                    ++subcell_distance;
                 }
             }
         }
@@ -218,18 +195,15 @@ 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(
+                    heap.Insert(to, to_weight, {false, duration + data.duration});
-                        to, to_weight, {false, duration + data.duration, distance + data.distance});
                 }
-                else if (std::tie(to_weight, to_duration, to_distance) <
+                else if (std::tie(to_weight, to_duration) <
-                         std::tie(
+                         std::tie(heap.GetKey(to), heap.GetData(to).duration))
-                             heap.GetKey(to), heap.GetData(to).duration, heap.GetData(to).distance))
                 {
                     heap.DecreaseKey(to, to_weight);
-                    heap.GetData(to) = {false, to_duration, to_distance};
+                    heap.GetData(to) = {false, to_duration};
                 }
             }
         }

include/customizer/cell_metric.hpp

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

include/customizer/edge_based_graph.hpp

@@ -58,10 +58,8 @@ class MultiLevelGraph : public partitioner::MultiLevelGraph<EdgeDataT, Ownership
 
     MultiLevelGraph(PartitionerGraphT &&graph,
                     Vector<EdgeWeight> node_weights_,
-                    Vector<EdgeDuration> node_durations_,
+                    Vector<EdgeDuration> node_durations_)
-                    Vector<EdgeDistance> node_distances_)
+        : node_weights(std::move(node_weights_)), node_durations(std::move(node_durations_))
-        : 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;
@@ -85,13 +83,11 @@ 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_)),
-          node_distances(std::move(node_distances_)), is_forward_edge(is_forward_edge_),
+          is_forward_edge(is_forward_edge_), is_backward_edge(is_backward_edge_)
-          is_backward_edge(is_backward_edge_)
     {
     }
 
@@ -99,8 +95,6 @@ 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]; }
@@ -117,7 +111,6 @@ 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,7 +23,6 @@ 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>
@@ -33,7 +32,6 @@ 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>
@@ -44,7 +42,6 @@ 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);
@@ -59,7 +56,6 @@ 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,15 +59,6 @@ struct TableParameters : public BaseParameters
 {
     std::vector<std::size_t> sources;
     std::vector<std::size_t> destinations;
-    double fallback_speed = 0;
-
-    enum class FallbackCoordinateType
-    {
-        Input = 0,
-        Snapped = 1
-    };
-
-    FallbackCoordinateType fallback_coordinate_type = FallbackCoordinateType::Input;
 
     enum class AnnotationsType
     {
@@ -99,19 +90,6 @@ struct TableParameters : public BaseParameters
     {
     }
 
-    template <typename... Args>
-    TableParameters(std::vector<std::size_t> sources_,
-                    std::vector<std::size_t> destinations_,
-                    const AnnotationsType annotations_,
-                    double fallback_speed_,
-                    FallbackCoordinateType fallback_coordinate_type_,
-                    Args... args_)
-        : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
-          destinations{std::move(destinations_)}, fallback_speed{fallback_speed_},
-          fallback_coordinate_type{fallback_coordinate_type_}, annotations{annotations_}
-    {
-    }
-
     bool IsValid() const
     {
         if (!BaseParameters::IsValid())
@@ -123,7 +101,14 @@ struct TableParameters : public BaseParameters
 
         // 1/ The user is able to specify duplicates in srcs and dsts, in that case it's their fault
 
-        // 2/ 0 <= index < len(locations)
+        // 2/ len(srcs) and len(dsts) smaller or equal to len(locations)
+        if (sources.size() > coordinates.size())
+            return false;
+
+        if (destinations.size() > coordinates.size())
+            return false;
+
+        // 3/ 0 <= index < len(locations)
         const auto not_in_range = [this](const std::size_t x) { return x >= coordinates.size(); };
 
         if (std::any_of(begin(sources), end(sources), not_in_range))
@@ -132,9 +117,6 @@ struct TableParameters : public BaseParameters
         if (std::any_of(begin(destinations), end(destinations), not_in_range))
             return false;
 
-        if (fallback_speed < 0)
-            return false;
-
         return true;
     }
 };

include/engine/datafacade/algorithm_datafacade.hpp

@@ -78,8 +78,6 @@ 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,11 +697,6 @@ 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,6 +34,8 @@ 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
@@ -234,7 +236,7 @@ struct PhantomNodes
     PhantomNode source_phantom;
     PhantomNode target_phantom;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // PHANTOM_NODES_H

include/engine/routing_algorithms.hpp

@@ -34,7 +34,8 @@ 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 = 0;
+                     const bool calculate_distance,
+                     const bool calculate_duration) const = 0;
 
     virtual routing_algorithms::SubMatchingList
     MapMatching(const routing_algorithms::CandidateLists &candidates_list,
@@ -87,7 +88,8 @@ 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 final override;
+                     const bool calculate_distance,
+                     const bool calculate_duration) const final override;
 
     routing_algorithms::SubMatchingList
     MapMatching(const routing_algorithms::CandidateLists &candidates_list,
@@ -196,7 +198,8 @@ 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
+                                               const bool calculate_distance,
+                                               const bool calculate_duration) const
 {
     BOOST_ASSERT(!phantom_nodes.empty());
 
@@ -219,7 +222,8 @@ RoutingAlgorithms<Algorithm>::ManyToManySearch(const std::vector<PhantomNode> &p
                                                 phantom_nodes,
                                                 std::move(source_indices),
                                                 std::move(target_indices),
-                                                calculate_distance);
+                                                calculate_distance,
+                                                calculate_duration);
 }
 
 template <typename Algorithm>

include/engine/routing_algorithms/many_to_many.hpp

@@ -97,7 +97,8 @@ 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_distance,
+                 const bool calculate_duration);
 
 } // namespace routing_algorithms
 } // namespace engine

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -509,6 +509,90 @@ 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);
 }
-} // ns extractor
+} // namespace extractor
-} // ns osrm
+} // namespace osrm
 
 #endif /* EDGE_BASED_EDGE_HPP */

include/extractor/edge_based_graph_factory.hpp

@@ -92,7 +92,6 @@ 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;
@@ -120,7 +119,6 @@ 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,7 +88,6 @@ 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 NodeWeightsVectorT>
+template <typename NodeWeigtsVectorT>
-void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVectorT &weights)
+void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeigtsVectorT &weights)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
@@ -462,33 +462,9 @@ void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVe
     storage::serialization::read(reader, "/extractor/edge_based_node_weights", weights);
 }
 
-template <typename NodeDistancesVectorT>
+template <typename NodeWeigtsVectorT, typename NodeDurationsVectorT>
-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,
-                                       NodeWeightsVectorT &weights,
+                                       NodeWeigtsVectorT &weights,
                                        NodeDurationsVectorT &durations)
 {
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@@ -498,9 +474,9 @@ void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
     storage::serialization::read(reader, "/extractor/edge_based_node_durations", durations);
 }
 
-template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
+template <typename NodeWeigtsVectorT, typename NodeDurationsVectorT>
 void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
-                                        const NodeWeightsVectorT &weights,
+                                        const NodeWeigtsVectorT &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.");
 
-} // ns extractor
+} // namespace extractor
-} // ns osrm
+} // namespace osrm
 
 #endif /* NODE_BASED_EDGE_HPP */

include/nodejs/node_osrm_support.hpp

@@ -1183,52 +1183,6 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         }
     }
 
-    if (obj->Has(Nan::New("fallback_speed").ToLocalChecked()))
-    {
-        auto fallback_speed = obj->Get(Nan::New("fallback_speed").ToLocalChecked());
-
-        if (!fallback_speed->IsNumber())
-        {
-            Nan::ThrowError("fallback_speed must be a number");
-            return table_parameters_ptr();
-        }
-        else if (fallback_speed->NumberValue() < 0)
-        {
-            Nan::ThrowError("fallback_speed must be > 0");
-            return table_parameters_ptr();
-        }
-
-        params->fallback_speed = static_cast<double>(fallback_speed->NumberValue());
-    }
-
-    if (obj->Has(Nan::New("fallback_coordinate").ToLocalChecked()))
-    {
-        auto fallback_coordinate = obj->Get(Nan::New("fallback_coordinate").ToLocalChecked());
-
-        if (!fallback_coordinate->IsString())
-        {
-            Nan::ThrowError("fallback_coordinate must be a string: [input, snapped]");
-            return table_parameters_ptr();
-        }
-
-        std::string fallback_coordinate_str = *v8::String::Utf8Value(fallback_coordinate);
-
-        if (fallback_coordinate_str == "snapped")
-        {
-            params->fallback_coordinate_type =
-                osrm::TableParameters::FallbackCoordinateType::Snapped;
-        }
-        else if (fallback_coordinate_str == "input")
-        {
-            params->fallback_coordinate_type = osrm::TableParameters::FallbackCoordinateType::Input;
-        }
-        else
-        {
-            Nan::ThrowError("'fallback_coordinate' param must be one of [input, snapped]");
-            return table_parameters_ptr();
-        }
-    }
-
     return params;
 }
 

include/partitioner/cell_storage.hpp

@@ -75,35 +75,28 @@ 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, typename DistanceValueT>
+    template <typename WeightValueT, typename DurationValueT> class CellImpl
-    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,
-        template <typename ValuePtrT>
+                                                             WeightValueT,
-        class ColumnIterator : public boost::iterator_facade<ColumnIterator<ValuePtrT>,
-                                                             decltype(*std::declval<ValuePtrT>()),
                                                              boost::random_access_traversal_tag>
         {
-
+            typedef boost::iterator_facade<ColumnIterator,
-            using ValueT = decltype(*std::declval<ValuePtrT>());
+                                           WeightValueT,
-            typedef boost::iterator_facade<ColumnIterator<ValueT>,
-                                           ValueT,
                                            boost::random_access_traversal_tag>
                 base_t;
 
@@ -115,7 +108,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
             explicit ColumnIterator() : current(nullptr), stride(1) {}
 
-            explicit ColumnIterator(ValuePtrT begin, std::size_t row_length)
+            explicit ColumnIterator(WeightPtrT begin, std::size_t row_length)
                 : current(begin), stride(row_length)
             {
                 BOOST_ASSERT(begin != nullptr);
@@ -133,7 +126,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
             }
 
             friend class ::boost::iterator_core_access;
-            ValuePtrT current;
+            WeightPtrT current;
             const std::size_t stride;
         };
 
@@ -154,13 +147,12 @@ 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<ValuePtr>{},
+                return boost::make_iterator_range(ColumnIterator{}, ColumnIterator{});
-                                                  ColumnIterator<ValuePtr>{});
 
             auto column = std::distance(destination_boundary, iter);
-            auto begin = ColumnIterator<ValuePtr>{ptr + column, num_destination_nodes};
+            auto begin = ColumnIterator{ptr + column, num_destination_nodes};
-            auto end = ColumnIterator<ValuePtr>{
+            auto end = ColumnIterator{ptr + column + num_source_nodes * num_destination_nodes,
-                ptr + column + num_source_nodes * num_destination_nodes, num_destination_nodes};
+                                      num_destination_nodes};
             return boost::make_iterator_range(begin, end);
         }
 
@@ -173,10 +165,6 @@ 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);
@@ -191,20 +179,17 @@ 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);
         }
@@ -216,8 +201,7 @@ 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}, distances{nullptr},
+              durations{nullptr}, source_boundary{all_sources + data.source_boundary_offset},
-              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);
@@ -228,8 +212,8 @@ template <storage::Ownership Ownership> class CellStorageImpl
     std::size_t LevelIDToIndex(LevelID level) const { return level - 1; }
 
   public:
-    using Cell = CellImpl<EdgeWeight, EdgeDuration, EdgeDistance>;
+    using Cell = CellImpl<EdgeWeight, EdgeDuration>;
-    using ConstCell = CellImpl<const EdgeWeight, const EdgeDuration, const EdgeDistance>;
+    using ConstCell = CellImpl<const EdgeWeight, const EdgeDuration>;
 
     CellStorageImpl() {}
 
@@ -377,7 +361,6 @@ 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;
     }
@@ -405,7 +388,6 @@ 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()};
     }
@@ -433,7 +415,6 @@ 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,6 +14,8 @@
 #include <tbb/parallel_for.h>
 #include <tbb/parallel_reduce.h>
 
+#include <iostream>
+
 #include <cstdint>
 
 #include <algorithm>
@@ -198,7 +200,7 @@ inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const boost::filesystem::path &p
     return DynamicEdgeBasedGraph(number_of_edge_based_nodes, std::move(tidied), checksum);
 }
 
-} // ns partition
+} // namespace partitioner
-} // ns osrm
+} // namespace osrm
 
 #endif

include/server/api/base_parameters_grammar.hpp

@@ -178,8 +178,6 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
     qi::rule<Iterator, Signature> base_rule;
     qi::rule<Iterator, Signature> query_rule;
 
-    qi::real_parser<double, json_policy> double_;
-
   private:
     qi::rule<Iterator, Signature> bearings_rule;
     qi::rule<Iterator, Signature> radiuses_rule;
@@ -197,6 +195,7 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
     qi::rule<Iterator, unsigned char()> base64_char;
     qi::rule<Iterator, std::string()> polyline_chars;
     qi::rule<Iterator, double()> unlimited_rule;
+    qi::real_parser<double, json_policy> double_;
 
     qi::symbols<char, engine::Approach> approach_type;
 };

include/server/api/table_parameter_grammar.hpp

@@ -48,24 +48,10 @@ struct TableParametersGrammar : public BaseParametersGrammar<Iterator, Signature
             (qi::lit("all") |
              (size_t_ % ';')[ph::bind(&engine::api::TableParameters::sources, qi::_r1) = qi::_1]);
 
-        fallback_speed_rule =
-            qi::lit("fallback_speed=") >
-            (double_)[ph::bind(&engine::api::TableParameters::fallback_speed, qi::_r1) = qi::_1];
-
-        fallback_coordinate_type.add("input",
-                                     engine::api::TableParameters::FallbackCoordinateType::Input)(
-            "snapped", engine::api::TableParameters::FallbackCoordinateType::Snapped);
-
         table_rule = destinations_rule(qi::_r1) | sources_rule(qi::_r1);
 
-        root_rule =
+        root_rule = BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
-            BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
+                    -('?' > (table_rule(qi::_r1) | base_rule(qi::_r1)) % '&');
-            -('?' > (table_rule(qi::_r1) | base_rule(qi::_r1) | fallback_speed_rule(qi::_r1) |
-                     (qi::lit("fallback_coordinate=") >
-                      fallback_coordinate_type
-                          [ph::bind(&engine::api::TableParameters::fallback_coordinate_type,
-                                    qi::_r1) = qi::_1])) %
-                        '&');
     }
 
     TableParametersGrammar(qi::rule<Iterator, Signature> &root_rule_) : BaseGrammar(root_rule_)
@@ -87,19 +73,13 @@ struct TableParametersGrammar : public BaseParametersGrammar<Iterator, Signature
     qi::rule<Iterator, Signature> base_rule;
 
   private:
-    using json_policy = no_trailing_dot_policy<double, 'j', 's', 'o', 'n'>;
-
     qi::rule<Iterator, Signature> root_rule;
     qi::rule<Iterator, Signature> table_rule;
     qi::rule<Iterator, Signature> sources_rule;
     qi::rule<Iterator, Signature> destinations_rule;
-    qi::rule<Iterator, Signature> fallback_speed_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;
-    qi::symbols<char, engine::api::TableParameters::FallbackCoordinateType>
-        fallback_coordinate_type;
-    qi::real_parser<double, json_policy> double_;
 };
 }
 }

include/storage/serialization.hpp

@@ -9,7 +9,6 @@
 #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>
 
@@ -34,10 +33,6 @@ 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.
@@ -54,10 +49,6 @@ 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);
@@ -71,16 +62,15 @@ void readBoolVector(tar::FileReader &reader, const std::string &name, VectorT &d
     data.resize(count);
     std::uint64_t index = 0;
 
-    using BlockType = std::uint64_t;
+    constexpr std::uint64_t WORD_BITS = CHAR_BIT * sizeof(std::uint64_t);
-    constexpr std::uint64_t BLOCK_BITS = CHAR_BIT * sizeof(BlockType);
 
-    const auto decode = [&](const BlockType block) {
+    const auto decode = [&](const std::uint64_t block) {
-        auto read_size = std::min<std::size_t>(count - index, BLOCK_BITS);
+        auto read_size = std::min<std::size_t>(count - index, WORD_BITS);
-        unpackBits<VectorT, BlockType>(data, index, read_size, block);
+        unpackBits<VectorT, std::uint64_t>(data, index, read_size, block);
-        index += BLOCK_BITS;
+        index += WORD_BITS;
     };
 
-    reader.ReadStreaming<BlockType>(name, boost::make_function_output_iterator(decode));
+    reader.ReadStreaming<std::uint64_t>(name, boost::make_function_output_iterator(decode));
 }
 
 template <typename VectorT>
@@ -90,25 +80,24 @@ void writeBoolVector(tar::FileWriter &writer, const std::string &name, const Vec
     writer.WriteElementCount64(name, count);
     std::uint64_t index = 0;
 
-    using BlockType = std::uint64_t;
+    constexpr std::uint64_t WORD_BITS = CHAR_BIT * sizeof(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<BlockType()> encode_function = [&]() -> BlockType {
+    const std::function<std::uint64_t()> encode_function = [&]() -> std::uint64_t {
-        auto write_size = std::min<std::size_t>(count - index, BLOCK_BITS);
+        auto write_size = std::min<std::size_t>(count - index, WORD_BITS);
-        auto packed = packBits<VectorT, BlockType>(data, index, write_size);
+        auto packed = packBits<VectorT, std::uint64_t>(data, index, write_size);
-        index += BLOCK_BITS;
+        index += WORD_BITS;
         return packed;
     };
 
-    std::uint64_t number_of_blocks = (count + BLOCK_BITS - 1) / BLOCK_BITS;
+    std::uint64_t number_of_blocks = (count + WORD_BITS - 1) / WORD_BITS;
-    writer.WriteStreaming<BlockType>(
+    writer.WriteStreaming<std::uint64_t>(
         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
@@ -284,14 +273,17 @@ template <typename K, typename V> void write(io::BufferWriter &writer, const std
     }
 }
 
-inline void read(io::BufferReader &reader, BaseDataLayout &layout) { read(reader, layout.blocks); }
+inline void read(io::BufferReader &reader, std::unique_ptr<BaseDataLayout> &layout)
-
-inline void write(io::BufferWriter &writer, const BaseDataLayout &layout)
 {
-    write(writer, layout.blocks);
+    read(reader, layout->blocks);
-}
-}
 }
+
+inline void write(io::BufferWriter &writer, const std::unique_ptr<BaseDataLayout> &layout)
+{
+    write(writer, layout->blocks);
 }
+} // namespace serialization
+} // namespace storage
+} // namespace osrm
 
 #endif

include/storage/shared_data_index.hpp

@@ -5,7 +5,6 @@
 
 #include <boost/function_output_iterator.hpp>
 
-#include <type_traits>
 #include <unordered_map>
 
 namespace osrm
@@ -20,7 +19,7 @@ class SharedDataIndex
   public:
     struct AllocatedRegion
     {
-        void *memory_ptr;
+        char *memory_ptr;
         std::unique_ptr<BaseDataLayout> layout;
     };
 
@@ -47,24 +46,12 @@ 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, BaseDataLayout &layout);
+inline void read(io::BufferReader &reader, std::unique_ptr<BaseDataLayout> &layout);
 
-inline void write(io::BufferWriter &writer, const BaseDataLayout &layout);
+inline void write(io::BufferWriter &writer, const std::unique_ptr<BaseDataLayout> &layout);
 } // namespace serialization
 
 namespace detail
@@ -59,22 +59,15 @@ class BaseDataLayout
   public:
     virtual ~BaseDataLayout() = default;
 
-    inline void SetBlock(const std::string &name, Block block) { blocks[name] = std::move(block); }
+    virtual inline void SetBlock(const std::string &name, Block block) = 0;
 
-    inline std::uint64_t GetBlockEntries(const std::string &name) const
+    virtual inline uint64_t GetBlockEntries(const std::string &name) const = 0;
-    {
-        return GetBlock(name).num_entries;
-    }
 
-    inline std::uint64_t GetBlockSize(const std::string &name) const
+    virtual inline uint64_t GetBlockSize(const std::string &name) const = 0;
-    {
-        return GetBlock(name).byte_size;
-    }
 
-    inline bool HasBlock(const std::string &name) const
+    virtual inline bool HasBlock(const std::string &name) const = 0;
-    {
+
-        return blocks.find(name) != blocks.end();
+    virtual inline uint64_t GetSizeOfLayout() const = 0;
-    }
 
     // Depending on the name prefix this function either lists all blocks with the same prefix
     // or all entries in the sub-directory.
@@ -99,10 +92,60 @@ class BaseDataLayout
         }
     }
 
-    virtual inline void *GetBlockPtr(void *base_ptr, const std::string &name) const = 0;
+    virtual inline void *GetBlockPtr(char *shared_memory, const std::string &name) const = 0;
-    virtual inline std::uint64_t GetSizeOfLayout() 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);
 
-  protected:
     const Block &GetBlock(const std::string &name) const
     {
         auto iter = blocks.find(name);
@@ -114,42 +157,10 @@ class 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<std::uintptr_t>(ptr);
+        const auto intptr = reinterpret_cast<uintptr_t>(ptr);
         const auto aligned = (intptr - 1u + BLOCK_ALIGNMENT) & -BLOCK_ALIGNMENT;
         return ptr = reinterpret_cast<void *>(aligned);
     }
@@ -178,9 +189,29 @@ class ContiguousDataLayout final : public BaseDataLayout
 class TarDataLayout final : public BaseDataLayout
 {
   public:
-    inline std::uint64_t GetSizeOfLayout() const override final
+    inline void SetBlock(const std::string &name, Block block) override final
     {
-        std::uint64_t result = 0;
+        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);
@@ -188,11 +219,28 @@ class TarDataLayout final : public BaseDataLayout
         return result;
     }
 
-    inline void *GetBlockPtr(void *base_ptr, const std::string &name) const override final
+    inline void *GetBlockPtr(char *memory_ptr, const std::string &name) const override final
     {
         auto offset = GetBlock(name).offset;
-        const auto offset_address = reinterpret_cast<std::uintptr_t>(base_ptr) + offset;
+        const auto offset_memory = memory_ptr + offset;
-        return reinterpret_cast<void *>(offset_address);
+        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;
     }
 };
 

include/storage/storage.hpp

@@ -35,15 +35,11 @@ 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:
@@ -52,9 +48,11 @@ 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(storage::BaseDataLayout &layout,
+    void PopulateLayout(std::unique_ptr<storage::BaseDataLayout> &layout,
-                        const std::vector<std::pair<bool, boost::filesystem::path>> &files);
+                        std::vector<std::pair<bool, boost::filesystem::path>> files);
-    std::string PopulateLayoutWithRTree(storage::BaseDataLayout &layout);
+    std::string PopulateLayoutWithRTree(std::unique_ptr<storage::BaseDataLayout> &layout);
+    void readBlocks(const boost::filesystem::path &path,
+                    std::unique_ptr<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,14 +294,11 @@ 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{
+    return customizer::CellMetricView{std::move(weights), std::move(durations)};
-        std::move(weights), std::move(durations), std::move(distances)};
 }
 
 inline auto make_cell_metric_view(const SharedDataIndex &index, const std::string &name)
@@ -314,14 +311,12 @@ 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{
+        cell_metric_excludes.push_back(
-            std::move(weights), std::move(durations), std::move(distances)});
+            customizer::CellMetricView{std::move(weights), std::move(durations)});
     }
 
     return cell_metric_excludes;
@@ -337,7 +332,6 @@ 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");
 
@@ -346,7 +340,6 @@ 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,17 +22,11 @@ class Updater
                                    std::vector<EdgeWeight> &node_weights,
                                    std::uint32_t &connectivity_checksum) const;
 
-    EdgeID LoadAndUpdateEdgeExpandedGraph(
+    EdgeID
-        std::vector<extractor::EdgeBasedEdge> &edge_based_edge_list,
+    LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &edge_based_edge_list,
-        std::vector<EdgeWeight> &node_weights,
+                                   std::vector<EdgeWeight> &node_weights,
-        std::vector<EdgeDuration> &node_durations, // TODO: remove when optional
+                                   std::vector<EdgeDuration> &node_durations, // TODO: to be deleted
-        std::uint32_t &connectivity_checksum) const;
+                                   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,7 +204,8 @@ 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 "rapidjson/msinttypes/stdint.h"
+#include "msinttypes/stdint.h"
 #include <intrin.h>
 #else
 #include <stdint.h>

include/util/node_based_graph.hpp

@@ -88,8 +88,12 @@ 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.weight >= 0);
-            BOOST_ASSERT(output_edge.data.duration > 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.distance >= 0);
         });
 
@@ -97,7 +101,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,7 +198,6 @@ 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);
     }
 
@@ -230,7 +229,6 @@ 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,11 +1,11 @@
 {
   "name": "osrm",
-  "version": "5.20.0",
+  "version": "5.20.0-alpha.4",
   "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": {
     "mkdirp": "^0.5.1",
-    "nan": "^2.11.1",
+    "nan": "^2.6.2",
     "node-cmake": "^2.3.2",
     "node-pre-gyp": "^0.6.36",
     "rimraf": "^2.5.4"
@@ -18,7 +18,7 @@
   },
   "scripts": {
     "lint": "node ./node_modules/eslint/bin/eslint.js -c ./.eslintrc features/step_definitions/ features/support/",
-    "test": "npm run lint && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify -m mmap && node ./node_modules/cucumber/bin/cucumber.js features/ -p mld && node ./node_modules/cucumber/bin/cucumber.js features/ -p mld -m mmap",
+    "test": "npm run lint && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify -m mmap",
     "clean": "rm -rf test/cache",
     "docs": "./scripts/build_api_docs.sh",
     "install": "node-pre-gyp install --fallback-to-build=false || ./scripts/node_install.sh",

profiles/car.lua

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

scripts/timer.js

@@ -6,12 +6,8 @@ var fs = require('fs');
 var name = process.argv[2];
 var cmd = process.argv.slice(3).join(' ');
 var start = Date.now();
-exec(cmd, (err, stdout, stderr) => {
+exec(cmd, (err) => {
-    if (err) {
+    if (err) return console.log(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,6 +102,7 @@ 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,7 +76,6 @@ 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);
@@ -85,8 +84,6 @@ 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<
@@ -127,11 +124,10 @@ 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: remove when durations are optional
+    std::vector<EdgeDuration> node_durations; // TODO: to be removed later
-    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, node_distances, connectivity_checksum);
+        config, mlp, node_weights, node_durations, 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, "
@@ -170,10 +166,8 @@ 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),
+    MultiLevelEdgeBasedGraph shaved_graph{
-                                          std::move(node_weights),
+        std::move(graph), std::move(node_weights), std::move(node_durations)};
-                                          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,8 +42,9 @@ MMapMemoryAllocator::MMapMemoryAllocator(const storage::StorageConfig &config)
         allocated_regions.push_back({&(rtree_filename[0]), std::move(fake_layout)});
     }
 
-    auto files = storage.GetStaticFiles();
+    std::vector<std::pair<bool, boost::filesystem::path>> files = storage.GetStaticFiles();
-    auto updatable_files = storage.GetUpdatableFiles();
+    std::vector<std::pair<bool, boost::filesystem::path>> updatable_files =
+        storage.GetUpdatableFiles();
     files.insert(files.end(), updatable_files.begin(), updatable_files.end());
 
     for (const auto &file : files)
@@ -55,13 +56,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::populateLayoutFromFile(file.second, *layout);
+            storage.readBlocks(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
-    auto static_files = storage.GetStaticFiles();
+    std::vector<std::pair<bool, boost::filesystem::path>> static_files = storage.GetStaticFiles();
-    auto updatable_files = storage.GetUpdatableFiles();
+    std::vector<std::pair<bool, boost::filesystem::path>> updatable_files =
-    std::unique_ptr<storage::BaseDataLayout> layout =
+        storage.GetUpdatableFiles();
-        std::make_unique<storage::ContiguousDataLayout>();
+    std::unique_ptr<storage::BaseDataLayout> layout = std::make_unique<storage::DataLayout>();
-    storage.PopulateLayoutWithRTree(*layout);
+    storage.PopulateLayoutWithRTree(layout);
-    storage.PopulateLayout(*layout, static_files);
+    storage.PopulateLayout(layout, static_files);
-    storage.PopulateLayout(*layout, updatable_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() {}
+ProcessMemoryAllocator::~ProcessMemoryAllocator() { /* free(internal_memory) */}
 
 const storage::SharedDataIndex &ProcessMemoryAllocator::GetIndex() { return index; }
 

src/engine/datafacade/shared_memory_allocator.cpp

@@ -25,9 +25,8 @@ 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::unique_ptr<storage::BaseDataLayout> layout = std::make_unique<storage::DataLayout>();
-            std::make_unique<storage::ContiguousDataLayout>();
+        storage::serialization::read(reader, layout);
-        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,7 +4,6 @@
 #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"
 
@@ -87,7 +86,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);
+        snapped_phantoms, params.sources, params.destinations, request_distance, request_duration);
 
     if ((request_duration && result_tables_pair.first.empty()) ||
         (request_distance && result_tables_pair.second.empty()))
@@ -95,42 +94,6 @@ 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.fallback_speed > 0)
-    {
-        for (std::size_t row = 0; row < num_sources; row++)
-        {
-            for (std::size_t column = 0; column < num_destinations; column++)
-            {
-                const auto &table_index = row * num_destinations + column;
-                BOOST_ASSERT(table_index < result_tables_pair.first.size());
-                if (result_tables_pair.first[table_index] == MAXIMAL_EDGE_DURATION)
-                {
-                    const auto &source =
-                        snapped_phantoms[params.sources.empty() ? row : params.sources[row]];
-                    const auto &destination =
-                        snapped_phantoms[params.destinations.empty() ? column
-                                                                     : params.destinations[column]];
-
-                    auto distance_estimate =
-                        params.fallback_coordinate_type ==
-                                api::TableParameters::FallbackCoordinateType::Input
-                            ? util::coordinate_calculation::fccApproximateDistance(
-                                  source.input_location, destination.input_location)
-                            : util::coordinate_calculation::fccApproximateDistance(
-                                  source.location, destination.location);
-
-                    result_tables_pair.first[table_index] =
-                        distance_estimate / (double)params.fallback_speed;
-                    if (!result_tables_pair.second.empty())
-                    {
-                        result_tables_pair.second[table_index] = distance_estimate;
-                    }
-                }
-            }
-        }
-    }
-
     api::TableAPI table_api{facade, params};
     table_api.MakeResponse(result_tables_pair, snapped_phantoms, result);
 

src/engine/plugins/trip.cpp

@@ -217,7 +217,10 @@ 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).first,
+        algorithms
+            .ManyToManySearch(
+                snapped_phantoms, {}, {}, /*requestDistance*/ false, /*requestDuration*/ true)
+            .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);
 }
-} // anon. namespace
+} // 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,13 +120,8 @@ 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 =
+        auto &current_distance = distances_table[row_index * number_of_targets + column_index];
-            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;
@@ -178,6 +173,160 @@ 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,
@@ -185,16 +334,18 @@ 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_distance,
+                 const bool calculate_duration)
 {
+    (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(calculate_distance ? number_of_entries : 0,
+    std::vector<EdgeDistance> distances_table(number_of_entries, MAXIMAL_EDGE_DISTANCE);
-                                              MAXIMAL_EDGE_DISTANCE);
     std::vector<NodeID> middle_nodes_table(number_of_entries, SPECIAL_NODEID);
 
     std::vector<NodeBucket> search_space_with_buckets;
@@ -247,6 +398,26 @@ 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,
+                        const EdgeDistance /* distance TODO use this */,
                         typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
                         Args... args)
 {
@@ -66,77 +66,65 @@ 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, to_distance});
+                        query_heap.Insert(to, to_weight, {node, true, to_duration, 0});
                     }
-                    else if (std::tie(to_weight, to_duration, to_distance, node) <
+                    else if (std::tie(to_weight, to_duration, 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, to_distance};
+                        query_heap.GetData(to) = {node, true, to_duration, 0};
                         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, to_distance});
+                        query_heap.Insert(to, to_weight, {node, true, to_duration, 0});
                     }
-                    else if (std::tie(to_weight, to_duration, to_distance, node) <
+                    else if (std::tie(to_weight, to_duration, 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, to_distance};
+                        query_heap.GetData(to) = {node, true, to_duration, 0};
                         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());
         }
     }
 
@@ -156,28 +144,25 @@ 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, to_distance});
+                query_heap.Insert(to, to_weight, {node, false, to_duration, 0});
             }
             // Found a shorter Path -> Update weight and set new parent
-            else if (std::tie(to_weight, to_duration, to_distance, node) <
+            else if (std::tie(to_weight, to_duration, 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, to_distance};
+                query_heap.GetData(to) = {node, false, to_duration, 0};
                 query_heap.DecreaseKey(to, to_weight);
             }
         }
@@ -194,12 +179,11 @@ 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(calculate_distance ? phantom_indices.size() : 0,
+    std::vector<EdgeDistance> distances_table(phantom_indices.size(), MAXIMAL_EDGE_DISTANCE);
-                                              MAXIMAL_EDGE_DISTANCE);
     std::vector<NodeID> middle_nodes_table(phantom_indices.size(), SPECIAL_NODEID);
 
     // Collect destination (source) nodes into a map
@@ -261,7 +245,7 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                 std::size_t index;
                 EdgeWeight target_weight;
                 EdgeDuration target_duration;
-                EdgeDistance target_distance;
+                EdgeDuration target_distance;
                 std::tie(index, target_weight, target_duration, target_distance) = it->second;
 
                 const auto path_weight = weight + target_weight;
@@ -270,16 +254,12 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                     const auto path_duration = duration + target_duration;
                     const auto path_distance = distance + target_distance;
 
-                    EdgeDistance nulldistance = 0;
+                    if (std::tie(path_weight, path_duration) <
-                    auto &current_distance =
+                        std::tie(weights[index], durations[index]))
-                        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;
-                        current_distance = path_distance;
+                        distances_table[index] = path_distance;
                         middle_nodes_table[index] = node;
                     }
 
@@ -297,7 +277,6 @@ 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);
 
@@ -324,7 +303,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 + facade.GetNodeDistance(node_id);
+                const auto edge_distance = initial_distance;
 
                 query_heap.Insert(to, edge_weight, {node, edge_duration, edge_distance});
             }
@@ -395,6 +374,128 @@ 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);
 }
 
@@ -410,7 +511,6 @@ 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)
 {
@@ -430,7 +530,6 @@ 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
@@ -441,21 +540,15 @@ 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, new_distance) <
+            std::tie(new_weight, new_duration) < std::tie(current_weight, current_duration))
-                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;
         }
     }
@@ -480,7 +573,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, target_distance);
+        node, parent, from_clique_arc, column_idx, target_weight, target_duration);
 
     const auto &partition = facade.GetMultiLevelPartition();
     const auto maximal_level = partition.GetNumberOfLevels() - 1;
@@ -531,6 +624,182 @@ 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,
@@ -546,8 +815,7 @@ 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(calculate_distance ? number_of_entries : 0,
+    std::vector<EdgeDistance> distances_table;
-                                              INVALID_EDGE_DISTANCE);
     std::vector<NodeID> middle_nodes_table(number_of_entries, SPECIAL_NODEID);
 
     std::vector<NodeBucket> search_space_with_buckets;
@@ -606,10 +874,26 @@ manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                                           search_space_with_buckets,
                                           weights_table,
                                           durations_table,
-                                          distances_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);
+        }
     }
 
     return std::make_pair(durations_table, distances_table);
@@ -636,8 +920,12 @@ 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_distance,
+                 const bool calculate_duration)
 {
+    (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,13 +114,6 @@ 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;
@@ -298,12 +291,8 @@ unsigned EdgeBasedGraphFactory::LabelEdgeBasedNodes()
 {
     // heuristic: node-based graph node is a simple intersection with four edges
     // (edge-based nodes)
-    constexpr std::size_t ESTIMATED_EDGE_COUNT = 4;
+    m_edge_based_node_weights.reserve(4 * m_node_based_graph.GetNumberOfNodes());
-    m_edge_based_node_weights.reserve(ESTIMATED_EDGE_COUNT * m_node_based_graph.GetNumberOfNodes());
+    m_edge_based_node_durations.reserve(4 * 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
@@ -321,7 +310,6 @@ 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;
@@ -419,8 +407,6 @@ 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++);
@@ -430,7 +416,6 @@ 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()
@@ -585,7 +570,6 @@ 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,
@@ -709,7 +693,6 @@ 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();
 
@@ -1048,7 +1031,6 @@ 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,7 +744,6 @@ 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),
@@ -861,7 +860,6 @@ 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,7 +242,6 @@ 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
@@ -323,7 +322,6 @@ 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);
 
@@ -347,10 +345,8 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
 
     util::Log() << "Saving edge-based node weights to file.";
     TIMER_START(timer_write_node_weights);
-    extractor::files::writeEdgeBasedNodeWeightsDurationsDistances(config.GetPath(".osrm.enw"),
+    extractor::files::writeEdgeBasedNodeWeightsDurations(
-                                                                  edge_based_node_weights,
+        config.GetPath(".osrm.enw"), edge_based_node_weights, edge_based_node_durations);
-                                                                  edge_based_node_durations,
-                                                                  edge_based_node_distances);
     TIMER_STOP(timer_write_node_weights);
     util::Log() << "Done writing. (" << TIMER_SEC(timer_write_node_weights) << ")";
 
@@ -740,7 +736,6 @@ 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)
 {
@@ -791,7 +786,6 @@ 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,6 +259,7 @@ 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);
@@ -268,18 +269,9 @@ 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);
 
@@ -291,7 +283,7 @@ void GraphCompressor::Compress(
                 graph.GetEdgeData(forward_e1).duration += forward_duration2;
                 graph.GetEdgeData(reverse_e1).duration += reverse_duration2;
 
-                // add distance of e2's to e1
+                // add duration of e2's to e1
                 graph.GetEdgeData(forward_e1).distance += forward_distance2;
                 graph.GetEdgeData(reverse_e1).distance += reverse_distance2;
 
@@ -376,5 +368,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`, `distances`, `sources`, and `destinations`.
+ * @returns {Object} containing `durations`, `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,15 +147,12 @@ 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);
-        util::inplacePermutation(node_distances.begin(), node_distances.end(), permutation);
+        extractor::files::writeEdgeBasedNodeWeightsDurations(
-        extractor::files::writeEdgeBasedNodeWeightsDurationsDistances(
+            config.GetPath(".osrm.enw"), node_weights, node_durations);
-            config.GetPath(".osrm.enw"), node_weights, node_durations, node_distances);
     }
     {
         const auto &filename = config.GetPath(".osrm.maneuver_overrides");

src/server/service/table_service.cpp

@@ -56,11 +56,6 @@ std::string getWrongOptionHelp(const engine::api::TableParameters &parameters)
         help = "Number of coordinates needs to be at least two.";
     }
 
-    if (parameters.fallback_speed < 0)
-    {
-        help = "fallback_speed must be > 0";
-    }
-
     return help;
 }
 } // anon. ns

src/storage/storage.cpp

@@ -51,8 +51,8 @@ struct RegionHandle
     std::uint16_t shm_key;
 };
 
-RegionHandle setupRegion(SharedRegionRegister &shared_register,
+auto setupRegion(SharedRegionRegister &shared_register,
-                         const storage::BaseDataLayout &layout)
+                 const std::unique_ptr<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 @@ RegionHandle 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,9 +165,12 @@ bool swapData(Monitor &monitor,
 
     return true;
 }
-}
+} // namespace
 
-void populateLayoutFromFile(const boost::filesystem::path &path, storage::BaseDataLayout &layout)
+Storage::Storage(StorageConfig config_) : config(std::move(config_)) {}
+
+void Storage::readBlocks(const boost::filesystem::path &path,
+                         std::unique_ptr<storage::BaseDataLayout> &layout)
 {
     tar::FileReader reader(path, tar::FileReader::VerifyFingerprint);
 
@@ -180,13 +183,11 @@ void populateLayoutFromFile(const boost::filesystem::path &path, storage::BaseDa
         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");
@@ -245,10 +246,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::ContiguousDataLayout>();
+            std::make_unique<storage::DataLayout>();
         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;
 
@@ -258,20 +259,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::ContiguousDataLayout>();
+            std::make_unique<storage::DataLayout>();
-        Storage::PopulateLayoutWithRTree(*static_layout);
+        Storage::PopulateLayoutWithRTree(static_layout);
         std::vector<std::pair<bool, boost::filesystem::path>> files = Storage::GetStaticFiles();
-        Storage::PopulateLayout(*static_layout, files);
+        Storage::PopulateLayout(static_layout, files);
-        auto static_handle = setupRegion(shared_register, *static_layout);
+        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::ContiguousDataLayout>();
+        std::make_unique<storage::DataLayout>();
     std::vector<std::pair<bool, boost::filesystem::path>> files = Storage::GetUpdatableFiles();
-    Storage::PopulateLayout(*updatable_layout, files);
+    Storage::PopulateLayout(updatable_layout, files);
-    auto updatable_handle = setupRegion(shared_register, *updatable_layout);
+    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);
 
@@ -343,18 +344,19 @@ std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetUpdatableFiles
     return files;
 }
 
-std::string Storage::PopulateLayoutWithRTree(storage::BaseDataLayout &layout)
+std::string Storage::PopulateLayoutWithRTree(std::unique_ptr<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
-    auto rtree_filename = absolute_file_index_path.string();
+    std::string 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;
 }
@@ -362,16 +364,16 @@ std::string Storage::PopulateLayoutWithRTree(storage::BaseDataLayout &layout)
 /**
  * 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 layout parameter.
+ * in that big block.  It updates the fields in the std::unique_ptr<BaseDataLayout> parameter.
  */
-void Storage::PopulateLayout(storage::BaseDataLayout &layout,
+void Storage::PopulateLayout(std::unique_ptr<storage::BaseDataLayout> &layout,
-                             const std::vector<std::pair<bool, boost::filesystem::path>> &files)
+                             std::vector<std::pair<bool, boost::filesystem::path>> files)
 {
     for (const auto &file : files)
     {
         if (boost::filesystem::exists(file.second))
         {
-            populateLayoutFromFile(file.second, layout);
+            readBlocks(file.second, layout);
         }
     }
 }
@@ -584,5 +586,5 @@ void Storage::PopulateUpdatableData(const SharedDataIndex &index)
         }
     }
 }
-}
+} // namespace storage
-}
+} // namespace osrm

src/tools/contract.cpp

@@ -81,7 +81,11 @@ 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");
+        "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.");
 
     // 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<ContiguousDataLayout>();
+            std::unique_ptr<BaseDataLayout> layout = std::make_unique<DataLayout>();
-            serialization::read(reader, *layout);
+            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'
+	# @/bin/sh -c '$(OSRM_ROUTED) --algorithm=MLD mld/$(DATA_NAME).osrm > /dev/null & echo "$$!" > osrm-routed.pid'
-	@sleep 1
+	# @sleep 1
-	$(TIMER) "queries\tMLD" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"
+	# $(TIMER) "queries\tMLD" "cat $(DATA_NAME).requests | xargs curl &> /dev/null"
-	@cat osrm-routed.pid | xargs kill
+	# @cat osrm-routed.pid | xargs kill
-	@rm osrm-routed.pid
+	# @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) {
+// test('match: match in Monaco without motorways', function(assert) {
-    assert.plan(3);
+//     assert.plan(3);
-    var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+//     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-    var options = {
+//     var options = {
-        coordinates: three_test_coordinates,
+//         coordinates: three_test_coordinates,
-        exclude: ['motorway']
+//         exclude: ['motorway']
-    };
+//     };
-    osrm.match(options, function(err, response) {
+//     osrm.match(options, function(err, response) {
-        assert.ifError(err);
+//         assert.ifError(err);
-        assert.equal(response.tracepoints.length, 3);
+//         assert.equal(response.tracepoints.length, 3);
-        assert.equal(response.matchings.length, 1);
+//         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) {
+// test('nearest: nearest in Monaco without motorways', function(assert) {
-    assert.plan(2);
+//     assert.plan(2);
-    var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+//     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-    var options = {
+//     var options = {
-        coordinates: [two_test_coordinates[0]],
+//         coordinates: [two_test_coordinates[0]],
-        exclude: ['motorway']
+//         exclude: ['motorway']
-    };
+//     };
-    osrm.nearest(options, function(err, response) {
+//     osrm.nearest(options, function(err, response) {
-        assert.ifError(err);
+//         assert.ifError(err);
-        assert.equal(response.waypoints.length, 1);
+//         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) {
+// test('route: route in Monaco without motorways', function(assert) {
-    assert.plan(3);
+//     assert.plan(3);
-    var osrm = new OSRM({path: monaco_mld_path, algorithm: 'MLD'});
+//     var osrm = new OSRM({path: monaco_mld_path, algorithm: 'MLD'});
-    var options = {
+//     var options = {
-        coordinates: two_test_coordinates,
+//         coordinates: two_test_coordinates,
-        exclude: ['motorway']
+//         exclude: ['motorway']
-    };
+//     };
-    osrm.route(options, function(err, response) {
+//     osrm.route(options, function(err, response) {
-        assert.ifError(err);
+//         assert.ifError(err);
-        assert.equal(response.waypoints.length, 2);
+//         assert.equal(response.waypoints.length, 2);
-        assert.equal(response.routes.length, 1);
+//         assert.equal(response.routes.length, 1);
-    });
+//     });
-});
+// });
 

test/nodejs/table.js

@@ -233,32 +233,17 @@ tables.forEach(function(annotation) {
         });
     });
 
-    test('table: ' + annotation + ' table in Monaco without motorways', function(assert) {
+    // test('table: ' + annotation + ' table in Monaco without motorways', function(assert) {
-        assert.plan(1);
+    //     assert.plan(1);
-        var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+    //     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-        var options = {
+    //     var options = {
-            coordinates: two_test_coordinates,
+    //         coordinates: two_test_coordinates,
-            exclude: ['motorway'],
+    //         exclude: ['motorway'],
-            annotations: [annotation.slice(0,-1)]
+    //         annotations: [annotation.slice(0,-1)]
-        };
+    //     };
-        osrm.table(options, function(err, response) {
+    //     osrm.table(options, function(err, response) {
-            assert.equal(response[annotation].length, 2);
+    //         assert.equal(response[annotation].length, 2);
-        });
+    //     });
-    });
+    // });
-
-    test('table: ' + annotation + ' table in Monaco with fallback speeds', function(assert) {
-        assert.plan(1);
-        var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-        var options = {
-            coordinates: two_test_coordinates,
-            annotations: [annotation.slice(0,-1)],
-            fallback_speed: 1,
-            fallback_coordinate: 'input'
-        };
-        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) {
+// test('trip: trip in Monaco without motorways', function(assert) {
-    assert.plan(3);
+//     assert.plan(3);
-    var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+//     var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-    var options = {
+//     var options = {
-        coordinates: two_test_coordinates,
+//         coordinates: two_test_coordinates,
-        exclude: ['motorway']
+//         exclude: ['motorway']
-    };
+//     };
-    osrm.trip(options, function(err, response) {
+//     osrm.trip(options, function(err, response) {
-        assert.ifError(err);
+//         assert.ifError(err);
-        assert.equal(response.waypoints.length, 2);
+//         assert.equal(response.waypoints.length, 2);
-        assert.equal(response.trips.length, 1);
+//         assert.equal(response.trips.length, 1);
-    });
+//     });
-});
+// });
 

unit_tests/contractor/contracted_edge_container.cpp

@@ -17,8 +17,7 @@ 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.distance << ", " << data.weight << ", " << data.forward << ", " << data.backward
+        << data.weight << ", " << data.forward << ", " << data.backward << "}";
-        << "}";
     return out;
 }
 
@@ -32,79 +31,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)
+// BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_graph)
-{
+// {
-    ContractedEdgeContainer container;
+//     ContractedEdgeContainer container;
 
-    std::vector<QueryEdge> edges;
+//     std::vector<QueryEdge> edges;
-    edges.push_back(QueryEdge{0, 1, {1, false, 3, 3, 6, true, false}});
+//     edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-    edges.push_back(QueryEdge{1, 2, {2, false, 3, 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, 3, 6, false, true}});
+//     edges.push_back(QueryEdge{2, 0, {3, false, 3, 6, false, true}});
-    edges.push_back(QueryEdge{2, 1, {4, false, 3, 3, 6, false, true}});
+//     edges.push_back(QueryEdge{2, 1, {4, false, 3, 6, false, true}});
-    container.Insert(edges);
+//     container.Insert(edges);
 
-    edges.clear();
+//     edges.clear();
-    edges.push_back(QueryEdge{0, 1, {1, false, 3, 3, 6, true, false}});
+//     edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-    edges.push_back(QueryEdge{1, 2, {2, false, 3, 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, 12, 24, false, true}});
+//     edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-    edges.push_back(QueryEdge{2, 1, {4, false, 12, 12, 24, false, true}});
+//     edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-    container.Merge(edges);
+//     container.Merge(edges);
 
-    edges.clear();
+//     edges.clear();
-    edges.push_back(QueryEdge{1, 4, {5, false, 3, 3, 6, true, false}});
+//     edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
-    container.Merge(edges);
+//     container.Merge(edges);
 
-    std::vector<QueryEdge> 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{0, 1, {1, false, 3, 6, true, false}});
-    reference_edges.push_back(QueryEdge{1, 2, {2, false, 3, 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, 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, 3, 6, false, true}});
+//     reference_edges.push_back(QueryEdge{2, 0, {3, false, 3, 6, false, true}});
-    reference_edges.push_back(QueryEdge{2, 0, {3, false, 12, 12, 24, 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, 3, 6, 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, 12, 24, false, true}});
+//     reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-    CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
+//     CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
 
-    auto filters = container.MakeEdgeFilters();
+//     auto filters = container.MakeEdgeFilters();
-    BOOST_CHECK_EQUAL(filters.size(), 2);
+//     BOOST_CHECK_EQUAL(filters.size(), 2);
 
-    REQUIRE_SIZE_RANGE(filters[0], 7);
+//     REQUIRE_SIZE_RANGE(filters[0], 7);
-    CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true, true, true);
+//     CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true, true, true);
 
-    REQUIRE_SIZE_RANGE(filters[1], 7);
+//     REQUIRE_SIZE_RANGE(filters[1], 7);
-    CHECK_EQUAL_RANGE(filters[1], true, true, true, true, false, true, false);
+//     CHECK_EQUAL_RANGE(filters[1], true, true, true, true, false, true, false);
-}
+// }
 
-BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_disjoint_graph)
+// BOOST_AUTO_TEST_CASE(merge_edge_of_multiple_disjoint_graph)
-{
+// {
-    ContractedEdgeContainer container;
+//     ContractedEdgeContainer container;
 
-    std::vector<QueryEdge> edges;
+//     std::vector<QueryEdge> edges;
-    edges.push_back(QueryEdge{0, 1, {1, false, 3, 3, 6, true, false}});
+//     edges.push_back(QueryEdge{0, 1, {1, false, 3, 6, true, false}});
-    edges.push_back(QueryEdge{1, 2, {2, false, 3, 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, 12, 24, false, true}});
+//     edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-    edges.push_back(QueryEdge{2, 1, {4, false, 12, 12, 24, false, true}});
+//     edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-    container.Merge(edges);
+//     container.Merge(edges);
 
-    edges.clear();
+//     edges.clear();
-    edges.push_back(QueryEdge{1, 4, {5, false, 3, 3, 6, true, false}});
+//     edges.push_back(QueryEdge{1, 4, {5, false, 3, 6, true, false}});
-    container.Merge(edges);
+//     container.Merge(edges);
 
-    std::vector<QueryEdge> 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{0, 1, {1, false, 3, 6, true, false}});
-    reference_edges.push_back(QueryEdge{1, 2, {2, false, 3, 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, 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, 12, 24, false, true}});
+//     reference_edges.push_back(QueryEdge{2, 0, {3, false, 12, 24, false, true}});
-    reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 12, 24, false, true}});
+//     reference_edges.push_back(QueryEdge{2, 1, {4, false, 12, 24, false, true}});
-    CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
+//     CHECK_EQUAL_COLLECTIONS(container.edges, reference_edges);
 
-    auto filters = container.MakeEdgeFilters();
+//     auto filters = container.MakeEdgeFilters();
-    BOOST_CHECK_EQUAL(filters.size(), 2);
+//     BOOST_CHECK_EQUAL(filters.size(), 2);
 
-    REQUIRE_SIZE_RANGE(filters[0], 5);
+//     REQUIRE_SIZE_RANGE(filters[0], 5);
-    CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true);
+//     CHECK_EQUAL_RANGE(filters[0], true, true, false, true, true);
 
-    REQUIRE_SIZE_RANGE(filters[1], 5);
+//     REQUIRE_SIZE_RANGE(filters[1], 5);
-    CHECK_EQUAL_RANGE(filters[1], false, false, true, false, false);
+//     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)
+// BOOST_AUTO_TEST_CASE(contract_graph)
-{
+// {
-    tbb::task_scheduler_init scheduler(1);
+//     tbb::task_scheduler_init scheduler(1);
-    /*
+//     /*
-     *                 <--1--<
+//      *                 <--1--<
-     * (0) >--3--> (1) >--3--> (3)
+//      * (0) >--3--> (1) >--3--> (3)
-     *  v          ^  v          ^
+//      *  v          ^  v          ^
-     *   \        /    \         |
+//      *   \        /    \         |
-     *    1      1      1        1
+//      *    1      1      1        1
-     *     \    ^        \       /
+//      *     \    ^        \       /
-     *      >(5)          > (4) >
+//      *      >(5)          > (4) >
-     */
+//      */
-    std::vector<TestEdge> edges = {TestEdge{0, 1, 3},
+//     std::vector<TestEdge> edges = {TestEdge{0, 1, 3},
-                                   TestEdge{0, 5, 1},
+//                                    TestEdge{0, 5, 1},
-                                   TestEdge{1, 3, 3},
+//                                    TestEdge{1, 3, 3},
-                                   TestEdge{1, 4, 1},
+//                                    TestEdge{1, 4, 1},
-                                   TestEdge{3, 1, 1},
+//                                    TestEdge{3, 1, 1},
-                                   TestEdge{4, 3, 1},
+//                                    TestEdge{4, 3, 1},
-                                   TestEdge{5, 1, 1}};
+//                                    TestEdge{5, 1, 1}};
-    auto reference_graph = makeGraph(edges);
+//     auto reference_graph = makeGraph(edges);
 
-    auto contracted_graph = reference_graph;
+//     auto contracted_graph = reference_graph;
-    std::vector<bool> core = contractGraph(contracted_graph, {1, 1, 1, 1, 1, 1});
+//     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
+//     // This contraction order is dependent on the priority caculation in the contractor
-    // but deterministic for the same graph.
+//     // but deterministic for the same graph.
-    CHECK_EQUAL_RANGE(core, false, false, false, false, false, false);
+//     CHECK_EQUAL_RANGE(core, false, false, false, false, false, false);
 
-    /* After contracting 0 and 2:
+//     /* After contracting 0 and 2:
-     *
+//      *
-     * Deltes edges 5 -> 0, 1 -> 0
+//      * Deltes edges 5 -> 0, 1 -> 0
-     *
+//      *
-     *                 <--1--<
+//      *                 <--1--<
-     * (0) ---3--> (1) >--3--> (3)
+//      * (0) ---3--> (1) >--3--> (3)
-     *  \          ^  v          ^
+//      *  \          ^  v          ^
-     *   \        /    \         |
+//      *   \        /    \         |
-     *    1      1      1        1
+//      *    1      1      1        1
-     *     \    ^        \       /
+//      *     \    ^        \       /
-     *      >(5)          > (4) >
+//      *      >(5)          > (4) >
-     */
+//      */
-    reference_graph.DeleteEdgesTo(5, 0);
+//     reference_graph.DeleteEdgesTo(5, 0);
-    reference_graph.DeleteEdgesTo(1, 0);
+//     reference_graph.DeleteEdgesTo(1, 0);
 
-    /* After contracting 5:
+//     /* After contracting 5:
-     *
+//      *
-     * Deletes edges 1 -> 5
+//      * Deletes edges 1 -> 5
-     *
+//      *
-     *                 <--1--<
+//      *                 <--1--<
-     * (0) ---3--> (1) >--3--> (3)
+//      * (0) ---3--> (1) >--3--> (3)
-     *  \          ^  v          ^
+//      *  \          ^  v          ^
-     *   \        /    \         |
+//      *   \        /    \         |
-     *    1      1      1        1
+//      *    1      1      1        1
-     *     \    /        \       /
+//      *     \    /        \       /
-     *      >(5)          > (4) >
+//      *      >(5)          > (4) >
-     */
+//      */
-    reference_graph.DeleteEdgesTo(5, 0);
+//     reference_graph.DeleteEdgesTo(5, 0);
-    reference_graph.DeleteEdgesTo(1, 0);
+//     reference_graph.DeleteEdgesTo(1, 0);
 
-    /* After contracting 3:
+//      After contracting 3:
-     *
+//      *
-     * Deletes edges 1 -> 3
+//      * Deletes edges 1 -> 3
-     * Deletes edges 4 -> 3
+//      * Deletes edges 4 -> 3
-     * Insert edge 4 -> 1
+//      * Insert edge 4 -> 1
-     *
+//      *
-     *                 <--1---
+//      *                 <--1---
-     * (0) ---3--> (1) >--3--- (3)
+//      * (0) ---3--> (1) >--3--- (3)
-     *  \          ^  v ^        |
+//      *  \          ^  v ^        |
-     *   \        /    \ \       |
+//      *   \        /    \ \       |
-     *    1      1      1 2      1
+//      *    1      1      1 2      1
-     *     \    /        \ \     /
+//      *     \    /        \ \     /
-     *      >(5)          > (4) >
+//      *      >(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});
 
-    /* After contracting 4:
+//     reference_graph.DeleteEdgesTo(1, 3);
-     *
+//     reference_graph.DeleteEdgesTo(4, 3);
-     * Delete edges 1 -> 4
+//     // Insert shortcut
-     *
+//     reference_graph.InsertEdge(4, 1, {2, 4, 3, 0, true, true, false});
-     *                 <--1---
-     * (0) ---3--> (1) >--3--- (3)
-     *  \          ^  v ^        |
-     *   \        /    \ \       |
-     *    1      1      1 2      1
-     *     \    /        \ \     /
-     *      >(5)          \ (4) >
-     */
-    reference_graph.DeleteEdgesTo(1, 4);
 
-    /* After contracting 1:
+//     /* After contracting 4:
-     *
+//      *
-     * Delete no edges.
+//      * Delete edges 1 -> 4
-     *
+//      *
-     *                 <--1---
+//      *                 <--1---
-     * (0) ---3--> (1) >--3--- (3)
+//      * (0) ---3--> (1) >--3--- (3)
-     *  \          ^  v ^        |
+//      *  \          ^  v ^        |
-     *   \        /    \ \       |
+//      *   \        /    \ \       |
-     *    1      1      1 2      1
+//      *    1      1      1 2      1
-     *     \    /        \ \     /
+//      *     \    /        \ \     /
-     *      >(5)          \ (4) >
+//      *      >(5)          \ (4) >
-     */
+//      */
+//     reference_graph.DeleteEdgesTo(1, 4);
 
-    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(0), 2);
+//     /* After contracting 1:
-    BOOST_CHECK(contracted_graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+//      *
-    BOOST_CHECK(contracted_graph.FindEdge(0, 5) != SPECIAL_EDGEID);
+//      * Delete no edges.
-    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(1), 0);
+//      *
-    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(2), 0);
+//      *                 <--1---
-    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(3), 3);
+//      * (0) ---3--> (1) >--3--- (3)
-    BOOST_CHECK(contracted_graph.FindEdge(3, 1) != SPECIAL_EDGEID);
+//      *  \          ^  v ^        |
-    BOOST_CHECK(contracted_graph.FindEdge(3, 4) != SPECIAL_EDGEID);
+//      *   \        /    \ \       |
-    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(4), 2);
+//      *    1      1      1 2      1
-    BOOST_CHECK(contracted_graph.FindEdge(4, 1) != SPECIAL_EDGEID);
+//      *     \    /        \ \     /
-    REQUIRE_SIZE_RANGE(contracted_graph.GetAdjacentEdgeRange(5), 1);
+//      *      >(5)          \ (4) >
-    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,19 +20,15 @@ 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{
+            contractor::ContractorEdgeData{weight, weight * 2, 1.0, id++, 0, false, true, false}});
-                weight, duration, distance, id++, 0, false, true, false}});
         input_edges.push_back(contractor::ContractorEdge{
             target,
             start,
-            contractor::ContractorEdgeData{
+            contractor::ContractorEdgeData{weight, weight * 2, 1.0, id++, 0, false, false, true}});
-                weight, duration, distance, id++, 0, false, false, true}});
     }
     std::sort(input_edges.begin(), input_edges.end());
 

unit_tests/customizer/cell_customization.cpp

@@ -27,7 +27,6 @@ auto makeGraph(const MultiLevelPartition &mlp, const std::vector<MockEdge> &mock
     {
         EdgeWeight weight;
         EdgeDuration duration;
-        EdgeDistance distance;
         bool forward;
         bool backward;
     };
@@ -37,20 +36,8 @@ 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,
+        edges.push_back(Edge{m.start, m.target, m.weight, 2 * m.weight, true, false});
-                             m.target,
+        edges.push_back(Edge{m.target, m.start, m.weight, 2 * m.weight, false, true});
-                             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/graph_compressor.hpp"
-#include "extractor/compressed_edge_container.hpp"
+// #include "extractor/compressed_edge_container.hpp"
-#include "extractor/maneuver_override.hpp"
+// #include "extractor/maneuver_override.hpp"
-#include "extractor/restriction.hpp"
+// #include "extractor/restriction.hpp"
-#include "util/node_based_graph.hpp"
+// #include "util/node_based_graph.hpp"
-#include "util/typedefs.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/test_case_template.hpp>
-#include <boost/test/unit_test.hpp>
+// #include <boost/test/unit_test.hpp>
 
-#include <iostream>
+// #include <iostream>
-#include <unordered_set>
+// #include <unordered_set>
-#include <vector>
+// #include <vector>
 
-BOOST_AUTO_TEST_SUITE(graph_compressor)
+// BOOST_AUTO_TEST_SUITE(graph_compressor)
 
-using namespace osrm;
+// using namespace osrm;
-using namespace osrm::extractor;
+// using namespace osrm::extractor;
-using InputEdge = util::NodeBasedDynamicGraph::InputEdge;
+// using InputEdge = util::NodeBasedDynamicGraph::InputEdge;
-using Graph = util::NodeBasedDynamicGraph;
+// using Graph = util::NodeBasedDynamicGraph;
 
-namespace
+// namespace
-{
+// {
 
-// creates a default edge of unit weight
+// // creates a default edge of unit weight
-inline InputEdge MakeUnitEdge(const NodeID from, const NodeID to)
+// inline InputEdge MakeUnitEdge(const NodeID from, const NodeID to)
-{
+// {
-    return {from,                          // source
+//     return {from,                          // source
-            to,                            // target
+//             to,                            // target
-            1,                             // weight
+//             1,                             // weight
-            1,                             // duration
+//             1,                             // duration
-            1,                             // distance
+//             GeometryID{0, false},          // geometry_id
-            GeometryID{0, false},          // geometry_id
+//             false,                         // reversed
-            false,                         // reversed
+//             NodeBasedEdgeClassification(), // default flags
-            NodeBasedEdgeClassification(), // default flags
+//             0};                            // AnnotationID
-            0};                            // AnnotationID
+// }
-}
 
-bool compatible(Graph const &graph,
+// bool compatible(Graph const &graph,
-                const std::vector<NodeBasedEdgeAnnotation> &node_data_container,
+//                 const std::vector<NodeBasedEdgeAnnotation> &node_data_container,
-                EdgeID const first,
+//                 EdgeID const first,
-                EdgeID second)
+//                 EdgeID second)
-{
+// {
-    auto const &first_flags = graph.GetEdgeData(first).flags;
+//     auto const &first_flags = graph.GetEdgeData(first).flags;
-    auto const &second_flags = graph.GetEdgeData(second).flags;
+//     auto const &second_flags = graph.GetEdgeData(second).flags;
-    if (!(first_flags == second_flags))
+//     if (!(first_flags == second_flags))
-        return false;
+//         return false;
 
-    if (graph.GetEdgeData(first).reversed != graph.GetEdgeData(second).reversed)
+//     if (graph.GetEdgeData(first).reversed != graph.GetEdgeData(second).reversed)
-        return false;
+//         return false;
 
-    auto const &first_annotation = node_data_container[graph.GetEdgeData(first).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];
+//     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)
+// BOOST_AUTO_TEST_CASE(long_road_test)
-{
+// {
-    //
+//     //
-    // 0---1---2---3---4
+//     // 0---1---2---3---4
-    //
+//     //
-    GraphCompressor compressor;
+//     GraphCompressor compressor;
 
-    std::unordered_set<NodeID> barrier_nodes;
+//     std::unordered_set<NodeID> barrier_nodes;
-    std::unordered_set<NodeID> traffic_lights;
+//     std::unordered_set<NodeID> traffic_lights;
-    std::vector<TurnRestriction> restrictions;
+//     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-    CompressedEdgeContainer container;
+//     CompressedEdgeContainer container;
-    test::MockScriptingEnvironment scripting_environment;
+//     test::MockScriptingEnvironment scripting_environment;
-    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-    std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
+//     std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
-                                    MakeUnitEdge(1, 0),
+//                                     MakeUnitEdge(1, 0),
-                                    MakeUnitEdge(1, 2),
+//                                     MakeUnitEdge(1, 2),
-                                    MakeUnitEdge(2, 1),
+//                                     MakeUnitEdge(2, 1),
-                                    MakeUnitEdge(2, 3),
+//                                     MakeUnitEdge(2, 3),
-                                    MakeUnitEdge(3, 2),
+//                                     MakeUnitEdge(3, 2),
-                                    MakeUnitEdge(3, 4),
+//                                     MakeUnitEdge(3, 4),
-                                    MakeUnitEdge(4, 3)};
+//                                     MakeUnitEdge(4, 3)};
 
-    Graph graph(5, edges);
+//     Graph graph(5, edges);
-    BOOST_CHECK(compatible(graph, annotations, 0, 2));
+//     BOOST_CHECK(compatible(graph, annotations, 0, 2));
-    BOOST_CHECK(compatible(graph, annotations, 2, 4));
+//     BOOST_CHECK(compatible(graph, annotations, 2, 4));
-    BOOST_CHECK(compatible(graph, annotations, 4, 6));
+//     BOOST_CHECK(compatible(graph, annotations, 4, 6));
 
-    compressor.Compress(barrier_nodes,
+//     compressor.Compress(barrier_nodes,
-                        traffic_lights,
+//                         traffic_lights,
-                        scripting_environment,
+//                         scripting_environment,
-                        restrictions,
+//                         restrictions,
-                        conditional_restrictions,
+//                         conditional_restrictions,
-                        maneuver_overrides,
+//                         maneuver_overrides,
-                        graph,
+//                         graph,
-                        annotations,
+//                         annotations,
-                        container);
+//                         container);
-    BOOST_CHECK_EQUAL(graph.FindEdge(0, 1), 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(1, 2), SPECIAL_EDGEID);
-    BOOST_CHECK_EQUAL(graph.FindEdge(2, 3), SPECIAL_EDGEID);
+//     BOOST_CHECK_EQUAL(graph.FindEdge(2, 3), SPECIAL_EDGEID);
-    BOOST_CHECK_EQUAL(graph.FindEdge(3, 4), SPECIAL_EDGEID);
+//     BOOST_CHECK_EQUAL(graph.FindEdge(3, 4), SPECIAL_EDGEID);
-    BOOST_CHECK(graph.FindEdge(0, 4) != SPECIAL_EDGEID);
+//     BOOST_CHECK(graph.FindEdge(0, 4) != SPECIAL_EDGEID);
-}
+// }
 
-BOOST_AUTO_TEST_CASE(loop_test)
+// BOOST_AUTO_TEST_CASE(loop_test)
-{
+// {
-    //
+//     //
-    // 0---1---2
+//     // 0---1---2
-    // |       |
+//     // |       |
-    // 5---4---3
+//     // 5---4---3
-    //
+//     //
-    GraphCompressor compressor;
+//     GraphCompressor compressor;
 
-    std::unordered_set<NodeID> barrier_nodes;
+//     std::unordered_set<NodeID> barrier_nodes;
-    std::unordered_set<NodeID> traffic_lights;
+//     std::unordered_set<NodeID> traffic_lights;
-    std::vector<TurnRestriction> restrictions;
+//     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-    CompressedEdgeContainer container;
+//     CompressedEdgeContainer container;
-    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-    test::MockScriptingEnvironment scripting_environment;
+//     test::MockScriptingEnvironment scripting_environment;
-    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-    std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
+//     std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
-                                    MakeUnitEdge(0, 5),
+//                                     MakeUnitEdge(0, 5),
-                                    MakeUnitEdge(1, 0),
+//                                     MakeUnitEdge(1, 0),
-                                    MakeUnitEdge(1, 2),
+//                                     MakeUnitEdge(1, 2),
-                                    MakeUnitEdge(2, 1),
+//                                     MakeUnitEdge(2, 1),
-                                    MakeUnitEdge(2, 3),
+//                                     MakeUnitEdge(2, 3),
-                                    MakeUnitEdge(3, 2),
+//                                     MakeUnitEdge(3, 2),
-                                    MakeUnitEdge(3, 4),
+//                                     MakeUnitEdge(3, 4),
-                                    MakeUnitEdge(4, 3),
+//                                     MakeUnitEdge(4, 3),
-                                    MakeUnitEdge(4, 5),
+//                                     MakeUnitEdge(4, 5),
-                                    MakeUnitEdge(5, 0),
+//                                     MakeUnitEdge(5, 0),
-                                    MakeUnitEdge(5, 4)};
+//                                     MakeUnitEdge(5, 4)};
 
-    Graph graph(6, edges);
+//     Graph graph(6, edges);
-    BOOST_CHECK(edges.size() == 12);
+//     BOOST_CHECK(edges.size() == 12);
-    BOOST_CHECK(compatible(graph, annotations, 0, 1));
+//     BOOST_CHECK(compatible(graph, annotations, 0, 1));
-    BOOST_CHECK(compatible(graph, annotations, 1, 2));
+//     BOOST_CHECK(compatible(graph, annotations, 1, 2));
-    BOOST_CHECK(compatible(graph, annotations, 2, 3));
+//     BOOST_CHECK(compatible(graph, annotations, 2, 3));
-    BOOST_CHECK(compatible(graph, annotations, 3, 4));
+//     BOOST_CHECK(compatible(graph, annotations, 3, 4));
-    BOOST_CHECK(compatible(graph, annotations, 4, 5));
+//     BOOST_CHECK(compatible(graph, annotations, 4, 5));
-    BOOST_CHECK(compatible(graph, annotations, 5, 6));
+//     BOOST_CHECK(compatible(graph, annotations, 5, 6));
-    BOOST_CHECK(compatible(graph, annotations, 6, 7));
+//     BOOST_CHECK(compatible(graph, annotations, 6, 7));
-    BOOST_CHECK(compatible(graph, annotations, 7, 8));
+//     BOOST_CHECK(compatible(graph, annotations, 7, 8));
-    BOOST_CHECK(compatible(graph, annotations, 8, 9));
+//     BOOST_CHECK(compatible(graph, annotations, 8, 9));
-    BOOST_CHECK(compatible(graph, annotations, 9, 10));
+//     BOOST_CHECK(compatible(graph, annotations, 9, 10));
-    BOOST_CHECK(compatible(graph, annotations, 10, 11));
+//     BOOST_CHECK(compatible(graph, annotations, 10, 11));
-    BOOST_CHECK(compatible(graph, annotations, 11, 0));
+//     BOOST_CHECK(compatible(graph, annotations, 11, 0));
 
-    compressor.Compress(barrier_nodes,
+//     compressor.Compress(barrier_nodes,
-                        traffic_lights,
+//                         traffic_lights,
-                        scripting_environment,
+//                         scripting_environment,
-                        restrictions,
+//                         restrictions,
-                        conditional_restrictions,
+//                         conditional_restrictions,
-                        maneuver_overrides,
+//                         maneuver_overrides,
-                        graph,
+//                         graph,
-                        annotations,
+//                         annotations,
-                        container);
+//                         container);
 
-    BOOST_CHECK_EQUAL(graph.FindEdge(5, 0), 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(0, 1), SPECIAL_EDGEID);
-    BOOST_CHECK_EQUAL(graph.FindEdge(1, 2), 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(2, 3), SPECIAL_EDGEID);
-    BOOST_CHECK(graph.FindEdge(5, 3) != SPECIAL_EDGEID);
+//     BOOST_CHECK(graph.FindEdge(5, 3) != SPECIAL_EDGEID);
-    BOOST_CHECK(graph.FindEdge(3, 4) != SPECIAL_EDGEID);
+//     BOOST_CHECK(graph.FindEdge(3, 4) != SPECIAL_EDGEID);
-    BOOST_CHECK(graph.FindEdge(4, 5) != SPECIAL_EDGEID);
+//     BOOST_CHECK(graph.FindEdge(4, 5) != SPECIAL_EDGEID);
-}
+// }
 
-BOOST_AUTO_TEST_CASE(t_intersection)
+// BOOST_AUTO_TEST_CASE(t_intersection)
-{
+// {
-    //
+//     //
-    // 0---1---2
+//     // 0---1---2
-    //     |
+//     //     |
-    //     3
+//     //     3
-    //
+//     //
-    GraphCompressor compressor;
+//     GraphCompressor compressor;
 
-    std::unordered_set<NodeID> barrier_nodes;
+//     std::unordered_set<NodeID> barrier_nodes;
-    std::unordered_set<NodeID> traffic_lights;
+//     std::unordered_set<NodeID> traffic_lights;
-    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-    std::vector<TurnRestriction> restrictions;
+//     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-    CompressedEdgeContainer container;
+//     CompressedEdgeContainer container;
-    test::MockScriptingEnvironment scripting_environment;
+//     test::MockScriptingEnvironment scripting_environment;
-    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-    std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
+//     std::vector<InputEdge> edges = {MakeUnitEdge(0, 1),
-                                    MakeUnitEdge(1, 0),
+//                                     MakeUnitEdge(1, 0),
-                                    MakeUnitEdge(1, 2),
+//                                     MakeUnitEdge(1, 2),
-                                    MakeUnitEdge(1, 3),
+//                                     MakeUnitEdge(1, 3),
-                                    MakeUnitEdge(2, 1),
+//                                     MakeUnitEdge(2, 1),
-                                    MakeUnitEdge(3, 1)};
+//                                     MakeUnitEdge(3, 1)};
 
-    Graph graph(4, edges);
+//     Graph graph(4, edges);
-    BOOST_CHECK(compatible(graph, annotations, 0, 1));
+//     BOOST_CHECK(compatible(graph, annotations, 0, 1));
-    BOOST_CHECK(compatible(graph, annotations, 1, 2));
+//     BOOST_CHECK(compatible(graph, annotations, 1, 2));
-    BOOST_CHECK(compatible(graph, annotations, 2, 3));
+//     BOOST_CHECK(compatible(graph, annotations, 2, 3));
-    BOOST_CHECK(compatible(graph, annotations, 3, 4));
+//     BOOST_CHECK(compatible(graph, annotations, 3, 4));
-    BOOST_CHECK(compatible(graph, annotations, 4, 5));
+//     BOOST_CHECK(compatible(graph, annotations, 4, 5));
 
-    compressor.Compress(barrier_nodes,
+//     compressor.Compress(barrier_nodes,
-                        traffic_lights,
+//                         traffic_lights,
-                        scripting_environment,
+//                         scripting_environment,
-                        restrictions,
+//                         restrictions,
-                        conditional_restrictions,
+//                         conditional_restrictions,
-                        maneuver_overrides,
+//                         maneuver_overrides,
-                        graph,
+//                         graph,
-                        annotations,
+//                         annotations,
-                        container);
+//                         container);
 
-    BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+//     BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-    BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
+//     BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
-    BOOST_CHECK(graph.FindEdge(1, 3) != SPECIAL_EDGEID);
+//     BOOST_CHECK(graph.FindEdge(1, 3) != SPECIAL_EDGEID);
-}
+// }
 
-BOOST_AUTO_TEST_CASE(street_name_changes)
+// BOOST_AUTO_TEST_CASE(street_name_changes)
-{
+// {
-    //
+//     //
-    // 0---1---2
+//     // 0---1---2
-    //
+//     //
-    GraphCompressor compressor;
+//     GraphCompressor compressor;
 
-    std::unordered_set<NodeID> barrier_nodes;
+//     std::unordered_set<NodeID> barrier_nodes;
-    std::unordered_set<NodeID> traffic_lights;
+//     std::unordered_set<NodeID> traffic_lights;
-    std::vector<NodeBasedEdgeAnnotation> annotations(2);
+//     std::vector<NodeBasedEdgeAnnotation> annotations(2);
-    std::vector<TurnRestriction> restrictions;
+//     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-    CompressedEdgeContainer container;
+//     CompressedEdgeContainer container;
-    test::MockScriptingEnvironment scripting_environment;
+//     test::MockScriptingEnvironment scripting_environment;
-    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-    std::vector<InputEdge> edges = {
+//     std::vector<InputEdge> edges = {
-        MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
+//         MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
 
-    annotations[1].name_id = 1;
+//     annotations[1].name_id = 1;
-    edges[2].data.annotation_data = edges[3].data.annotation_data = 1;
+//     edges[2].data.annotation_data = edges[3].data.annotation_data = 1;
 
-    Graph graph(5, edges);
+//     Graph graph(5, edges);
-    BOOST_CHECK(compatible(graph, annotations, 0, 1));
+//     BOOST_CHECK(compatible(graph, annotations, 0, 1));
-    BOOST_CHECK(compatible(graph, annotations, 2, 3));
+//     BOOST_CHECK(compatible(graph, annotations, 2, 3));
 
-    compressor.Compress(barrier_nodes,
+//     compressor.Compress(barrier_nodes,
-                        traffic_lights,
+//                         traffic_lights,
-                        scripting_environment,
+//                         scripting_environment,
-                        restrictions,
+//                         restrictions,
-                        conditional_restrictions,
+//                         conditional_restrictions,
-                        maneuver_overrides,
+//                         maneuver_overrides,
-                        graph,
+//                         graph,
-                        annotations,
+//                         annotations,
-                        container);
+//                         container);
 
-    BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+//     BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-    BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
+//     BOOST_CHECK(graph.FindEdge(1, 2) != SPECIAL_EDGEID);
-}
+// }
 
-BOOST_AUTO_TEST_CASE(direction_changes)
+// BOOST_AUTO_TEST_CASE(direction_changes)
-{
+// {
-    //
+//     //
-    // 0-->1---2
+//     // 0-->1---2
-    //
+//     //
-    GraphCompressor compressor;
+//     GraphCompressor compressor;
 
-    std::unordered_set<NodeID> barrier_nodes;
+//     std::unordered_set<NodeID> barrier_nodes;
-    std::unordered_set<NodeID> traffic_lights;
+//     std::unordered_set<NodeID> traffic_lights;
-    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-    std::vector<TurnRestriction> restrictions;
+//     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-    CompressedEdgeContainer container;
+//     CompressedEdgeContainer container;
-    test::MockScriptingEnvironment scripting_environment;
+//     test::MockScriptingEnvironment scripting_environment;
-    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-    std::vector<InputEdge> edges = {
+//     std::vector<InputEdge> edges = {
-        MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
+//         MakeUnitEdge(0, 1), MakeUnitEdge(1, 0), MakeUnitEdge(1, 2), MakeUnitEdge(2, 1)};
-    // make first edge point forward
+//     // make first edge point forward
-    edges[1].data.reversed = true;
+//     edges[1].data.reversed = true;
 
-    Graph graph(5, edges);
+//     Graph graph(5, edges);
-    compressor.Compress(barrier_nodes,
+//     compressor.Compress(barrier_nodes,
-                        traffic_lights,
+//                         traffic_lights,
-                        scripting_environment,
+//                         scripting_environment,
-                        restrictions,
+//                         restrictions,
-                        conditional_restrictions,
+//                         conditional_restrictions,
-                        maneuver_overrides,
+//                         maneuver_overrides,
-                        graph,
+//                         graph,
-                        annotations,
+//                         annotations,
-                        container);
+//                         container);
 
-    BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
+//     BOOST_CHECK(graph.FindEdge(0, 1) != SPECIAL_EDGEID);
-    BOOST_CHECK(graph.FindEdge(1, 2) != 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,307 +17,306 @@ using namespace osrm::extractor::intersection;
 using InputEdge = util::NodeBasedDynamicGraph::InputEdge;
 using Graph = util::NodeBasedDynamicGraph;
 
-BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
+// BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
-{
+// {
-    std::unordered_set<NodeID> barrier_nodes{6};
+//     std::unordered_set<NodeID> barrier_nodes{6};
-    std::unordered_set<NodeID> traffic_lights;
+//     std::unordered_set<NodeID> traffic_lights;
-    std::vector<NodeBasedEdgeAnnotation> annotations{
+//     std::vector<NodeBasedEdgeAnnotation> annotations{
-        {EMPTY_NAMEID, 0, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false},
+//         {EMPTY_NAMEID, 0, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false},
-        {EMPTY_NAMEID, 1, 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<TurnRestriction> restrictions{TurnRestriction{NodeRestriction{0, 2, 1}, false}};
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-    CompressedEdgeContainer container;
+//     CompressedEdgeContainer container;
-    test::MockScriptingEnvironment scripting_environment;
+//     test::MockScriptingEnvironment scripting_environment;
-    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-    TurnLanesIndexedArray turn_lanes_data{{0, 0, 3},
+//     TurnLanesIndexedArray turn_lanes_data{{0, 0, 3},
-                                          {TurnLaneType::uturn | TurnLaneType::left,
+//                                           {TurnLaneType::uturn | TurnLaneType::left,
-                                           TurnLaneType::straight,
+//                                            TurnLaneType::straight,
-                                           TurnLaneType::straight | TurnLaneType::right}};
+//                                            TurnLaneType::straight | TurnLaneType::right}};
 
-    // Graph with an additional turn restriction 0→2→1 and bollard at 6
+//     // Graph with an additional turn restriction 0→2→1 and bollard at 6
-    //   0→5↔6↔7
+//     //   0→5↔6↔7
-    //   ↕
+//     //   ↕
-    // 1↔2←3
+//     // 1↔2←3
-    //   ↓
+//     //   ↓
-    //   4
+//     //   4
-    const auto unit_edge =
+//     const auto unit_edge =
-        [](const NodeID from, const NodeID to, bool allowed, AnnotationID annotation) {
+//         [](const NodeID from, const NodeID to, bool allowed, AnnotationID annotation) {
-            return InputEdge{from,
+//             return InputEdge{from,
-                             to,
+//                              to,
-                             1,
+//                              1,
-                             1,
+//                              1,
-                             1,
+//                              GeometryID{0, false},
-                             GeometryID{0, false},
+//                              !allowed,
-                             !allowed,
+//                              NodeBasedEdgeClassification(),
-                             NodeBasedEdgeClassification(),
+//                              annotation};
-                             annotation};
+//         };
-        };
 
-    std::vector<InputEdge> edges = {unit_edge(0, 2, true, 1),
+//     std::vector<InputEdge> edges = {unit_edge(0, 2, true, 1),
-                                    unit_edge(0, 5, true, 0),
+//                                     unit_edge(0, 5, true, 0),
-                                    unit_edge(1, 2, true, 0),
+//                                     unit_edge(1, 2, true, 0),
-                                    unit_edge(2, 0, true, 0),
+//                                     unit_edge(2, 0, true, 0),
-                                    unit_edge(2, 1, true, 0),
+//                                     unit_edge(2, 1, true, 0),
-                                    unit_edge(2, 3, false, 0),
+//                                     unit_edge(2, 3, false, 0),
-                                    unit_edge(2, 4, true, 0),
+//                                     unit_edge(2, 4, true, 0),
-                                    unit_edge(3, 2, true, 0),
+//                                     unit_edge(3, 2, true, 0),
-                                    unit_edge(4, 2, false, 0),
+//                                     unit_edge(4, 2, false, 0),
-                                    unit_edge(5, 0, false, 0),
+//                                     unit_edge(5, 0, false, 0),
-                                    unit_edge(5, 6, true, 0),
+//                                     unit_edge(5, 6, true, 0),
-                                    unit_edge(6, 5, true, 0),
+//                                     unit_edge(6, 5, true, 0),
-                                    unit_edge(6, 7, true, 0),
+//                                     unit_edge(6, 7, true, 0),
-                                    unit_edge(7, 6, true, 0)};
+//                                     unit_edge(7, 6, true, 0)};
-    IntersectionEdgeGeometries edge_geometries{
+//     IntersectionEdgeGeometries edge_geometries{
-        {0, 180, 180, 10.},  // 0→2
+//         {0, 180, 180, 10.},  // 0→2
-        {1, 90, 90, 10.},    // 0→5
+//         {1, 90, 90, 10.},    // 0→5
-        {2, 90, 90, 10.},    // 1→2
+//         {2, 90, 90, 10.},    // 1→2
-        {3, 0, 0, 10.},      // 2→0
+//         {3, 0, 0, 10.},      // 2→0
-        {4, 270, 270, 10.},  // 2→1
+//         {4, 270, 270, 10.},  // 2→1
-        {5, 90, 90, 10.},    // 2→3
+//         {5, 90, 90, 10.},    // 2→3
-        {6, 180, 180, 10.},  // 2→4
+//         {6, 180, 180, 10.},  // 2→4
-        {7, 270, 270, 10.},  // 3→2
+//         {7, 270, 270, 10.},  // 3→2
-        {8, 0, 0, 10.},      // 4→2
+//         {8, 0, 0, 10.},      // 4→2
-        {9, 270, 270, 10.},  // 5→0
+//         {9, 270, 270, 10.},  // 5→0
-        {10, 90, 90, 10.},   // 5→6
+//         {10, 90, 90, 10.},   // 5→6
-        {11, 270, 270, 10.}, // 6→5
+//         {11, 270, 270, 10.}, // 6→5
-        {12, 90, 90, 10.},   // 6→7
+//         {12, 90, 90, 10.},   // 6→7
-        {13, 270, 270, 10.}  // 7→6
+//         {13, 270, 270, 10.}  // 7→6
-    };
+//     };
 
-    Graph graph(8, edges);
+//     Graph graph(8, edges);
 
-    GraphCompressor().Compress(barrier_nodes,
+//     GraphCompressor().Compress(barrier_nodes,
-                               traffic_lights,
+//                                traffic_lights,
-                               scripting_environment,
+//                                scripting_environment,
-                               restrictions,
+//                                restrictions,
-                               conditional_restrictions,
+//                                conditional_restrictions,
-                               maneuver_overrides,
+//                                maneuver_overrides,
-                               graph,
+//                                graph,
-                               annotations,
+//                                annotations,
-                               container);
+//                                container);
 
-    REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 2), 3);
+//     REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 2), 3);
-    REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 2), 4);
+//     REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 2), 4);
 
-    EdgeBasedNodeDataContainer node_data_container(
+//     EdgeBasedNodeDataContainer node_data_container(
-        std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
+//         std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
-    RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
+//     RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
 
-    const auto connectivity_matrix = [&](NodeID node) {
+//     const auto connectivity_matrix = [&](NodeID node) {
-        std::vector<bool> result;
+//         std::vector<bool> result;
-        const auto incoming_edges = getIncomingEdges(graph, node);
+//         const auto incoming_edges = getIncomingEdges(graph, node);
-        const auto outgoing_edges = getOutgoingEdges(graph, node);
+//         const auto outgoing_edges = getOutgoingEdges(graph, node);
-        for (const auto incoming_edge : incoming_edges)
+//         for (const auto incoming_edge : incoming_edges)
-        {
+//         {
-            for (const auto outgoing_edge : outgoing_edges)
+//             for (const auto outgoing_edge : outgoing_edges)
-            {
+//             {
-                result.push_back(isTurnAllowed(graph,
+//                 result.push_back(isTurnAllowed(graph,
-                                               node_data_container,
+//                                                node_data_container,
-                                               restriction_map,
+//                                                restriction_map,
-                                               barrier_nodes,
+//                                                barrier_nodes,
-                                               edge_geometries,
+//                                                edge_geometries,
-                                               turn_lanes_data,
+//                                                turn_lanes_data,
-                                               incoming_edge,
+//                                                incoming_edge,
-                                               outgoing_edge));
+//                                                outgoing_edge));
-            }
+//             }
-        }
+//         }
-        return result;
+//         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(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(1), 1);    // from node 2 allowed U-turn
-    CHECK_EQUAL_RANGE(connectivity_matrix(2),
+//     CHECK_EQUAL_RANGE(connectivity_matrix(2),
-                      // clang-format off
+//                       // 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 0 to node 4 and a U-turn at 2
-                      1, 0, 0, 1, // from node 1 to nodes 0 and 4
+//                       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
+//                       1, 1, 0, 1  // from node 3 to nodes 0, 1 and 4
-                      // clang-format on
+//                       // clang-format on
-                      );
+//                       );
-    REQUIRE_SIZE_RANGE(connectivity_matrix(3), 0); // no incoming edges, empty matrix
+//     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(4), 0);  // from node 2 not allowed U-turn
-    CHECK_EQUAL_RANGE(connectivity_matrix(5),
+//     CHECK_EQUAL_RANGE(connectivity_matrix(5),
-                      // clang-format off
+//                       // clang-format off
-                      0, 1, // from node 0 to node 6
+//                       0, 1, // from node 0 to node 6
-                      0, 1, // from node 6 a U-turn to node 6
+//                       0, 1, // from node 6 a U-turn to node 6
-                      // clang-format on
+//                       // clang-format on
-                      );
+//                       );
 
-    CHECK_EQUAL_RANGE(connectivity_matrix(6),
+//     CHECK_EQUAL_RANGE(connectivity_matrix(6),
-                      // clang-format off
+//                       // clang-format off
-                      1, 0, // from node 5 a U-turn to node 5
+//                       1, 0, // from node 5 a U-turn to node 5
-                      0, 1, // from node 7 a U-turn to node 7
+//                       0, 1, // from node 7 a U-turn to node 7
-                      // clang-format on
+//                       // clang-format on
-                      );
+//                       );
-}
+// }
 
-BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
+// BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
-{
+// {
-    std::unordered_set<NodeID> barrier_nodes;
+//     std::unordered_set<NodeID> barrier_nodes;
-    std::unordered_set<NodeID> traffic_lights;
+//     std::unordered_set<NodeID> traffic_lights;
-    std::vector<NodeBasedEdgeAnnotation> annotations;
+//     std::vector<NodeBasedEdgeAnnotation> annotations;
-    std::vector<TurnRestriction> restrictions;
+//     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-    CompressedEdgeContainer container;
+//     CompressedEdgeContainer container;
-    test::MockScriptingEnvironment scripting_environment;
+//     test::MockScriptingEnvironment scripting_environment;
-    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-    TurnLanesIndexedArray turn_lanes_data;
+//     TurnLanesIndexedArray turn_lanes_data;
 
-    // Graph with roundabout edges 5→0→2
+//     // Graph with roundabout edges 5→0→2
-    //  1  2  3
+//     //  1  2  3
-    //   ↘ ↑ ↙
+//     //   ↘ ↑ ↙
-    //     0
+//     //     0
-    //   ↙ ↑ ↘
+//     //   ↙ ↑ ↘
-    //  4  5  6
+//     //  4  5  6
-    const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed, bool roundabout) {
+//     const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed, bool roundabout)
-        return InputEdge{from,
+//     {
-                         to,
+//         return InputEdge{from,
-                         1,
+//                          to,
-                         1,
+//                          1,
-                         1,
+//                          1,
-                         GeometryID{0, false},
+//                          GeometryID{0, false},
-                         !allowed,
+//                          !allowed,
-                         NodeBasedEdgeClassification{
+//                          NodeBasedEdgeClassification{
-                             true, false, false, roundabout, false, false, false, {}, 0, 0},
+//                              true, false, false, roundabout, false, false, false, {}, 0, 0},
-                         0};
+//                          0};
-    };
+//     };
-    std::vector<InputEdge> edges = {unit_edge(0, 1, false, false),
+//     std::vector<InputEdge> edges = {unit_edge(0, 1, false, false),
-                                    unit_edge(0, 2, true, true),
+//                                     unit_edge(0, 2, true, true),
-                                    unit_edge(0, 3, false, false),
+//                                     unit_edge(0, 3, false, false),
-                                    unit_edge(0, 4, true, false),
+//                                     unit_edge(0, 4, true, false),
-                                    unit_edge(0, 5, false, true),
+//                                     unit_edge(0, 5, false, true),
-                                    unit_edge(0, 6, true, false),
+//                                     unit_edge(0, 6, true, false),
-                                    unit_edge(1, 0, true, false),
+//                                     unit_edge(1, 0, true, false),
-                                    unit_edge(2, 0, false, true),
+//                                     unit_edge(2, 0, false, true),
-                                    unit_edge(3, 0, true, false),
+//                                     unit_edge(3, 0, true, false),
-                                    unit_edge(4, 0, false, false),
+//                                     unit_edge(4, 0, false, false),
-                                    unit_edge(5, 0, true, true),
+//                                     unit_edge(5, 0, true, true),
-                                    unit_edge(6, 0, false, false)};
+//                                     unit_edge(6, 0, false, false)};
-    IntersectionEdgeGeometries edge_geometries{
+//     IntersectionEdgeGeometries edge_geometries{
-        {0, 315, 315, 10}, // 0→1
+//         {0, 315, 315, 10}, // 0→1
-        {1, 0, 0, 10},     // 0→2
+//         {1, 0, 0, 10},     // 0→2
-        {2, 45, 45, 10},   // 0→3
+//         {2, 45, 45, 10},   // 0→3
-        {3, 225, 225, 10}, // 0→4
+//         {3, 225, 225, 10}, // 0→4
-        {4, 180, 180, 10}, // 0→5
+//         {4, 180, 180, 10}, // 0→5
-        {5, 135, 135, 10}, // 0→6
+//         {5, 135, 135, 10}, // 0→6
-        {6, 135, 135, 10}, // 1→0
+//         {6, 135, 135, 10}, // 1→0
-        {7, 180, 180, 10}, // 2→0
+//         {7, 180, 180, 10}, // 2→0
-        {8, 225, 225, 10}, // 3→0
+//         {8, 225, 225, 10}, // 3→0
-        {9, 45, 45, 10},   // 4→0
+//         {9, 45, 45, 10},   // 4→0
-        {10, 0, 0, 10},    // 5→0
+//         {10, 0, 0, 10},    // 5→0
-        {11, 315, 315, 10} // 6→0
+//         {11, 315, 315, 10} // 6→0
-    };
+//     };
 
-    Graph graph(7, edges);
+//     Graph graph(7, edges);
 
-    GraphCompressor().Compress(barrier_nodes,
+//     GraphCompressor().Compress(barrier_nodes,
-                               traffic_lights,
+//                                traffic_lights,
-                               scripting_environment,
+//                                scripting_environment,
-                               restrictions,
+//                                restrictions,
-                               conditional_restrictions,
+//                                conditional_restrictions,
-                               maneuver_overrides,
+//                                maneuver_overrides,
-                               graph,
+//                                graph,
-                               annotations,
+//                                annotations,
-                               container);
+//                                container);
 
-    REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 0), 3);
+//     REQUIRE_SIZE_RANGE(getIncomingEdges(graph, 0), 3);
-    REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 0), 6);
+//     REQUIRE_SIZE_RANGE(getOutgoingEdges(graph, 0), 6);
 
-    EdgeBasedNodeDataContainer node_data_container(
+//     EdgeBasedNodeDataContainer node_data_container(
-        std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
+//         std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
-    RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
+//     RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
 
-    const auto connectivity_matrix = [&](NodeID node) {
+//     const auto connectivity_matrix = [&](NodeID node) {
-        std::vector<bool> result;
+//         std::vector<bool> result;
-        const auto incoming_edges = getIncomingEdges(graph, node);
+//         const auto incoming_edges = getIncomingEdges(graph, node);
-        const auto outgoing_edges = getOutgoingEdges(graph, node);
+//         const auto outgoing_edges = getOutgoingEdges(graph, node);
-        for (const auto incoming_edge : incoming_edges)
+//         for (const auto incoming_edge : incoming_edges)
-        {
+//         {
-            for (const auto outgoing_edge : outgoing_edges)
+//             for (const auto outgoing_edge : outgoing_edges)
-            {
+//             {
-                result.push_back(isTurnAllowed(graph,
+//                 result.push_back(isTurnAllowed(graph,
-                                               node_data_container,
+//                                                node_data_container,
-                                               restriction_map,
+//                                                restriction_map,
-                                               barrier_nodes,
+//                                                barrier_nodes,
-                                               edge_geometries,
+//                                                edge_geometries,
-                                               turn_lanes_data,
+//                                                turn_lanes_data,
-                                               incoming_edge,
+//                                                incoming_edge,
-                                               outgoing_edge));
+//                                                outgoing_edge));
-            }
+//             }
-        }
+//         }
-        return result;
+//         return result;
-    };
+//     };
 
-    CHECK_EQUAL_RANGE(connectivity_matrix(0),
+//     CHECK_EQUAL_RANGE(connectivity_matrix(0),
-                      // clang-format off
+//                       // clang-format off
-                      0, 1, 0, 0, 0, 1, // from node 1 to nodes 2 and 6
+//                       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, 0, // from node 3 to nodes 2 and 4
-                      0, 1, 0, 1, 0, 1  // from node 5 to nodes 2, 4 and 6
+//                       0, 1, 0, 1, 0, 1  // from node 5 to nodes 2, 4 and 6
-                      // clang-format on
+//                       // clang-format on
-                      );
+//                       );
-}
+// }
 
-BOOST_AUTO_TEST_CASE(skip_degree_two_nodes)
+// BOOST_AUTO_TEST_CASE(skip_degree_two_nodes)
-{
+// {
-    std::unordered_set<NodeID> barrier_nodes{1};
+//     std::unordered_set<NodeID> barrier_nodes{1};
-    std::unordered_set<NodeID> traffic_lights{2};
+//     std::unordered_set<NodeID> traffic_lights{2};
-    std::vector<NodeBasedEdgeAnnotation> annotations(1);
+//     std::vector<NodeBasedEdgeAnnotation> annotations(1);
-    std::vector<TurnRestriction> restrictions;
+//     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
+//     std::vector<ConditionalTurnRestriction> conditional_restrictions;
-    CompressedEdgeContainer container;
+//     CompressedEdgeContainer container;
-    test::MockScriptingEnvironment scripting_environment;
+//     test::MockScriptingEnvironment scripting_environment;
-    std::vector<UnresolvedManeuverOverride> maneuver_overrides;
+//     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
 
-    TurnLanesIndexedArray turn_lanes_data;
+//     TurnLanesIndexedArray turn_lanes_data;
 
-    // Graph
+//     // Graph
-    //
+//     //
-    //  0↔1→2↔3↔4→5         7
+//     //  0↔1→2↔3↔4→5         7
-    //          ↑          ↕ ↕
+//     //          ↑          ↕ ↕
-    //          6         8 ↔ 9
+//     //          6         8 ↔ 9
-    //
+//     //
-    const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed) {
+//     const auto unit_edge = [](const NodeID from, const NodeID to, bool allowed) {
-        return InputEdge{
+//         return InputEdge{
-            from, to, 1, 1, 1, GeometryID{0, false}, !allowed, NodeBasedEdgeClassification{}, 0};
+//             from, to, 1, 1, GeometryID{0, false}, !allowed, NodeBasedEdgeClassification{}, 0};
-    };
+//     };
-    std::vector<InputEdge> edges = {unit_edge(0, 1, true), // 0
+//     std::vector<InputEdge> edges = {unit_edge(0, 1, true), // 0
-                                    unit_edge(1, 0, true),
+//                                     unit_edge(1, 0, true),
-                                    unit_edge(1, 2, true),
+//                                     unit_edge(1, 2, true),
-                                    unit_edge(2, 1, false),
+//                                     unit_edge(2, 1, false),
-                                    unit_edge(2, 3, true),
+//                                     unit_edge(2, 3, true),
-                                    unit_edge(3, 2, true), // 5
+//                                     unit_edge(3, 2, true), // 5
-                                    unit_edge(3, 4, true),
+//                                     unit_edge(3, 4, true),
-                                    unit_edge(4, 3, true),
+//                                     unit_edge(4, 3, true),
-                                    unit_edge(4, 5, true),
+//                                     unit_edge(4, 5, true),
-                                    unit_edge(4, 6, false),
+//                                     unit_edge(4, 6, false),
-                                    unit_edge(5, 4, false), // 10
+//                                     unit_edge(5, 4, false), // 10
-                                    unit_edge(6, 4, true),
+//                                     unit_edge(6, 4, true),
-                                    // Circle
+//                                     // Circle
-                                    unit_edge(7, 8, true), // 12
+//                                     unit_edge(7, 8, true), // 12
-                                    unit_edge(7, 9, true),
+//                                     unit_edge(7, 9, true),
-                                    unit_edge(8, 7, true),
+//                                     unit_edge(8, 7, true),
-                                    unit_edge(8, 9, true),
+//                                     unit_edge(8, 9, true),
-                                    unit_edge(9, 7, true),
+//                                     unit_edge(9, 7, true),
-                                    unit_edge(9, 8, true)};
+//                                     unit_edge(9, 8, true)};
 
-    Graph graph(10, edges);
+//     Graph graph(10, edges);
 
-    GraphCompressor().Compress(barrier_nodes,
+//     GraphCompressor().Compress(barrier_nodes,
-                               traffic_lights,
+//                                traffic_lights,
-                               scripting_environment,
+//                                scripting_environment,
-                               restrictions,
+//                                restrictions,
-                               conditional_restrictions,
+//                                conditional_restrictions,
-                               maneuver_overrides,
+//                                maneuver_overrides,
-                               graph,
+//                                graph,
-                               annotations,
+//                                annotations,
-                               container);
+//                                container);
 
-    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {0, 0}).edge), 4);
+//     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, {4, 7}).edge), 0);
-    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {5, 10}).edge), 4);
+//     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, {6, 11}).edge), 4);
-    BOOST_CHECK_EQUAL(graph.GetTarget(skipDegreeTwoNodes(graph, {7, 12}).edge), 7);
+//     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)
+// BOOST_AUTO_TEST_CASE(test_extract_with_valid_config)
-{
+// {
-    osrm::ExtractorConfig config;
+//     osrm::ExtractorConfig config;
-    config.input_path = OSRM_TEST_DATA_DIR "/monaco.osm.pbf";
+//     config.input_path = OSRM_TEST_DATA_DIR "/monaco.osm.pbf";
-    config.UseDefaultOutputNames(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();
+//     config.requested_num_threads = tbb::task_scheduler_init::default_num_threads();
-    BOOST_CHECK_NO_THROW(osrm::extract(config));
+//     BOOST_CHECK_NO_THROW(osrm::extract(config));
-}
+// }
 
 BOOST_AUTO_TEST_SUITE_END()

unit_tests/server/parameters_parser.cpp

@@ -89,8 +89,6 @@ BOOST_AUTO_TEST_CASE(invalid_table_urls)
     BOOST_CHECK_EQUAL(
         testInvalidOptions<TableParameters>("1,2;3,4?sources=all&destinations=all&annotations=bla"),
         49UL);
-    BOOST_CHECK_EQUAL(testInvalidOptions<TableParameters>("1,2;3,4?fallback_coordinate=asdf"),
-                      28UL);
 }
 
 BOOST_AUTO_TEST_CASE(valid_route_hint)

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<ContiguousDataLayout>();
+    std::unique_ptr<BaseDataLayout> layout = std::make_unique<DataLayout>();
 
     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<ContiguousDataLayout>();
+    std::unique_ptr<BaseDataLayout> layout = std::make_unique<DataLayout>();
 
     Block block_1{20, 8 * 20};
     Block block_2{1, 4 * 1};

unit_tests/storage/serialization.cpp

@@ -1,15 +1,11 @@
 #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;
@@ -19,48 +15,20 @@ 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), 0x74);
+    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 0, 8), 0x2e);
-    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 5, 7), 0x53);
+    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 5, 7), 0x65);
-    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 6, 8), 0xa9);
+    BOOST_CHECK_EQUAL(storage::serialization::detail::packBits(v, 6, 8), 0x95);
     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, 0x74u);
+    storage::serialization::detail::unpackBits(v, 0, 8, 0x2e);
-    storage::serialization::detail::unpackBits(v, 5, 7, 0x53u);
+    storage::serialization::detail::unpackBits(v, 5, 7, 0x65);
-    storage::serialization::detail::unpackBits(v, 6, 8, 0xa9u);
+    storage::serialization::detail::unpackBits(v, 6, 8, 0x95);
-    storage::serialization::detail::unpackBits(v, 11, 1, 0x01u);
+    storage::serialization::detail::unpackBits(v, 11, 1, 0x01);
     BOOST_CHECK_EQUAL_COLLECTIONS(v.begin(), v.end(), expected.begin(), expected.end());
 }
 

unit_tests/updater/timezoner.cpp

@@ -12,46 +12,50 @@ using namespace osrm::updater;
 
 BOOST_AUTO_TEST_CASE(timezoner_test)
 {
-    const char json[] =
+    // const char json[] =
-        "{ \"type\" : \"FeatureCollection\", \"features\": ["
+    //     "{ \"type\" : \"FeatureCollection\", \"features\": ["
-        "{ \"type\" : \"Feature\","
+    //     "{ \"type\" : \"Feature\","
-        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+    //     \"polygon\", "
-        "48.88277], [8.57757, 49.07206], [8.28369, "
+    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    std::time_t now = time(0);
+    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
-    BOOST_CHECK_NO_THROW(Timezoner tz(json, now));
+    // 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::filesystem::path test_path(TEST_DATA_DIR "/test.geojson");
-    BOOST_CHECK_NO_THROW(Timezoner tz(test_path, now));
+    // BOOST_CHECK_NO_THROW(Timezoner tz(test_path, now));
 
     // missing opening bracket
-    const char bad[] =
+    // const char bad[] =
-        "\"type\" : \"FeatureCollection\", \"features\": ["
+    //     "\"type\" : \"FeatureCollection\", \"features\": ["
-        "{ \"type\" : \"Feature\","
+    //     "{ \"type\" : \"Feature\","
-        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+    //     \"polygon\", "
-        "48.88277], [8.57757, 49.07206], [8.28369, "
+    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    BOOST_CHECK_THROW(Timezoner tz(bad, now), util::exception);
+    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
+    // BOOST_CHECK_THROW(Timezoner tz(bad, now), util::exception);
 
     // missing/malformed FeatureCollection type field
-    const char missing_type[] =
+    // const char missing_type[] =
-        "{ \"FeatureCollection\", \"features\": ["
+    //     "{ \"FeatureCollection\", \"features\": ["
-        "{ \"type\" : \"Feature\","
+    //     "{ \"type\" : \"Feature\","
-        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+    //     \"polygon\", "
-        "48.88277], [8.57757, 49.07206], [8.28369, "
+    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    BOOST_CHECK_THROW(Timezoner tz(missing_type, now), util::exception);
+    //     "49.07206], [8.28369, 48.88277]]] }} ]}";
+    // BOOST_CHECK_THROW(Timezoner tz(missing_type, now), util::exception);
 
-    const char missing_featc[] =
+    // const char missing_featc[] =
-        "{ \"type\" : \"Collection\", \"features\": ["
+    //     "{ \"type\" : \"Collection\", \"features\": ["
-        "{ \"type\" : \"Feature\","
+    //     "{ \"type\" : \"Feature\","
-        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-        "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+    //     \"polygon\", "
-        "48.88277], [8.57757, 49.07206], [8.28369, "
+    //     "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-        "49.07206], [8.28369, 48.88277]]] }} ]}";
+    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    BOOST_CHECK_THROW(Timezoner tz(missing_featc, now), util::exception);
+    //     "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,68 +71,74 @@ 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\","
+    // char tzid_err[] = "{ \"type\" : \"Feature\","
-                      "\"properties\" : { \"TZID\" : []}, \"geometry\" : { \"type\": \"polygon\", "
+    //                   "\"properties\" : { \"TZID\" : []}, \"geometry\" : { \"type\": \"polygon\",
-                      "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+    //                   "
-                      "48.88277], [8.57757, 49.07206], [8.28369, "
+    //                   "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-                      "49.07206], [8.28369, 48.88277]]] }}";
+    //                   "48.88277], [8.57757, 49.07206], [8.28369, "
-    doc.Parse(tzid_err);
+    //                   "49.07206], [8.28369, 48.88277]]] }}";
-    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    // doc.Parse(tzid_err);
+    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    char missing_geom[] = "{ \"type\" : \"Feature\","
+    // char missing_geom[] = "{ \"type\" : \"Feature\","
-                          "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometries\" : { "
+    //                       "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometries\" : { "
-                          "\"type\": \"polygon\", "
+    //                       "\"type\": \"polygon\", "
-                          "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+    //                       "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-                          "48.88277], [8.57757, 49.07206], [8.28369, "
+    //                       "48.88277], [8.57757, 49.07206], [8.28369, "
-                          "49.07206], [8.28369, 48.88277]]] }}";
+    //                       "49.07206], [8.28369, 48.88277]]] }}";
-    doc.Parse(missing_geom);
+    // doc.Parse(missing_geom);
-    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    char nonobj_geom[] =
+    // char nonobj_geom[] =
-        "{ \"type\" : \"Feature\","
+    //     "{ \"type\" : \"Feature\","
-        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : [ \"type\", \"polygon\", "
+    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : [ \"type\",
-        "\"coordinates\", [[[8.28369,48.88277], [8.57757, "
+    //     \"polygon\", "
-        "48.88277], [8.57757, 49.07206], [8.28369, "
+    //     "\"coordinates\", [[[8.28369,48.88277], [8.57757, "
-        "49.07206], [8.28369, 48.88277]]] ]}";
+    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    doc.Parse(nonobj_geom);
+    //     "49.07206], [8.28369, 48.88277]]] ]}";
-    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    // doc.Parse(nonobj_geom);
+    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    char missing_geom_type[] = "{ \"type\" : \"Feature\","
+    // char missing_geom_type[] = "{ \"type\" : \"Feature\","
-                               "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { "
+    //                            "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" :
-                               "\"no_type\": \"polygon\", "
+    //                            { "
-                               "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+    //                            "\"no_type\": \"polygon\", "
-                               "48.88277], [8.57757, 49.07206], [8.28369, "
+    //                            "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-                               "49.07206], [8.28369, 48.88277]]] }}";
+    //                            "48.88277], [8.57757, 49.07206], [8.28369, "
-    doc.Parse(missing_geom_type);
+    //                            "49.07206], [8.28369, 48.88277]]] }}";
-    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    // doc.Parse(missing_geom_type);
+    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    char nonstring_geom_type[] = "{ \"type\" : \"Feature\","
+    // char nonstring_geom_type[] = "{ \"type\" : \"Feature\","
-                                 "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : "
+    //                              "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\"
-                                 "{ \"type\": [\"polygon\"], "
+    //                              : "
-                                 "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+    //                              "{ \"type\": [\"polygon\"], "
-                                 "48.88277], [8.57757, 49.07206], [8.28369, "
+    //                              "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-                                 "49.07206], [8.28369, 48.88277]]] }}";
+    //                              "48.88277], [8.57757, 49.07206], [8.28369, "
-    doc.Parse(nonstring_geom_type);
+    //                              "49.07206], [8.28369, 48.88277]]] }}";
-    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    // doc.Parse(nonstring_geom_type);
+    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    char missing_coords[] =
+    // char missing_coords[] =
-        "{ \"type\" : \"Feature\","
+    //     "{ \"type\" : \"Feature\","
-        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-        "\"coords\": [[[8.28369,48.88277], [8.57757, "
+    //     \"polygon\", "
-        "48.88277], [8.57757, 49.07206], [8.28369, "
+    //     "\"coords\": [[[8.28369,48.88277], [8.57757, "
-        "49.07206], [8.28369, 48.88277]]] }}";
+    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    doc.Parse(missing_coords);
+    //     "49.07206], [8.28369, 48.88277]]] }}";
-    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    // doc.Parse(missing_coords);
+    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    char missing_outerring[] =
+    // char missing_outerring[] =
-        "{ \"type\" : \"Feature\","
+    //     "{ \"type\" : \"Feature\","
-        "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\": \"polygon\", "
+    //     "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometry\" : { \"type\":
-        "\"coordinates\": [[8.28369,48.88277], [8.57757, "
+    //     \"polygon\", "
-        "48.88277], [8.57757, 49.07206], [8.28369, "
+    //     "\"coordinates\": [[8.28369,48.88277], [8.57757, "
-        "49.07206], [8.28369, 48.88277]] }}";
+    //     "48.88277], [8.57757, 49.07206], [8.28369, "
-    doc.Parse(missing_outerring);
+    //     "49.07206], [8.28369, 48.88277]] }}";
-    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
+    // doc.Parse(missing_outerring);
+    // BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 }
 BOOST_AUTO_TEST_SUITE_END()