Prepare 5.22.0-rc.2

.travis.yml

@@ -36,10 +36,6 @@ env:
    - ENABLE_NODE_BINDINGS=On
    - NODE="10"
 
-stages:
-  - core
-  - optional
-
 matrix:
   fast_finish: true
 
@@ -47,14 +43,12 @@ matrix:
   include:
 
     # Debug Builds
-    - stage: core
-      os: linux
+    - os: linux
       compiler: "format-taginfo-docs"
       env: NODE=10
       sudo: false
       before_install:
       install:
-        - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash
         - source $NVM_DIR/nvm.sh
         - nvm install $NODE
         - nvm use $NODE
@@ -281,135 +275,7 @@ matrix:
       after_success:
         - ./scripts/travis/publish.sh
 
-    - os: osx
-      stage: optional
-      osx_image: xcode9.2
-      compiler: "mason-osx-release-node-latest"
-      # 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="node"
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-latest-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="node"
-      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-latest-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="node"
-      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: osx
-      osx_image: xcode9.2
-      compiler: "mason-osx-release-node-lts"
-      # 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="--lts"
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-lts-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="--lts"
-      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-lts-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="--lts"
-      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
-
-  allow_failures:
-    - compiler: "mason-osx-release-node-latest"
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="node"
-    - compiler: "node-latest-mason-linux-release"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="node"
-    - compiler: "node-latest-mason-linux-debug"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="node"
-    - compiler: "mason-osx-release-node-lts"
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="--lts"
-    - compiler: "node-lts-mason-linux-release"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="--lts"
-    - compiler: "node-lts-mason-linux-debug"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="--lts"
-
 before_install:
-  - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash
   - source $NVM_DIR/nvm.sh
   - nvm install $NODE
   - nvm use $NODE

CHANGELOG.md

@@ -1,13 +1,7 @@
-# Unreleased
+# 5.22.0-rc.2
   - Changes from 5.21.0
-    - Build:
-      - ADDED: optionally build Node `lts` and `latest` bindings [#5347](https://github.com/Project-OSRM/osrm-backend/pull/5347)
     - Features:
       - ADDED: new waypoints parameter to the `route` plugin, enabling silent waypoints [#5345](https://github.com/Project-OSRM/osrm-backend/pull/5345)
-      - ADDED: data timestamp information in the response (saved in new file `.osrm.timestamp`). [#5115](https://github.com/Project-OSRM/osrm-backend/issues/5115)
-      - ADDED: new API parameter - `snapping=any|default` to allow snapping to previously unsnappable edges [#5361](https://github.com/Project-OSRM/osrm-backend/pull/5361)
-    - Routing:
-      - CHANGED: allow routing past `barrier=arch` [#5352](https://github.com/Project-OSRM/osrm-backend/pull/5352)
 
 # 5.21.0
   - Changes from 5.20.0

README.md

@@ -58,16 +58,16 @@ Download OpenStreetMap extracts for example from [Geofabrik](http://download.geo
 
 Pre-process the extract with the car profile and start a routing engine HTTP server on port 5000
 
-    docker run -t -v "${PWD}:/data" osrm/osrm-backend osrm-extract -p /opt/car.lua /data/berlin-latest.osm.pbf
+    docker run -t -v $(pwd):/data osrm/osrm-backend osrm-extract -p /opt/car.lua /data/berlin-latest.osm.pbf
 
-The flag `-v "${PWD}:/data"` creates the directory `/data` inside the docker container and makes the current working directory `"${PWD}"` available there. The file `/data/berlin-latest.osm.pbf` inside the container is referring to `"${PWD}/berlin-latest.osm.pbf"` on the host.
+The flag `-v $(pwd):/data` creates the directory `/data` inside the docker container and makes the current working directory `$(pwd)` available there. The file `/data/berlin-latest.osm.pbf` inside the container is referring to `$(pwd)/berlin-latest.osm.pbf` on the host.
 
-    docker run -t -v "${PWD}:/data" osrm/osrm-backend osrm-partition /data/berlin-latest.osrm
-    docker run -t -v "${PWD}:/data" osrm/osrm-backend osrm-customize /data/berlin-latest.osrm
+    docker run -t -v $(pwd):/data osrm/osrm-backend osrm-partition /data/berlin-latest.osrm
+    docker run -t -v $(pwd):/data osrm/osrm-backend osrm-customize /data/berlin-latest.osrm
 
 Note that `berlin-latest.osrm` has a different file extension. 
 
-    docker run -t -i -p 5000:5000 -v "${PWD}:/data" osrm/osrm-backend osrm-routed --algorithm mld /data/berlin-latest.osrm
+    docker run -t -i -p 5000:5000 -v $(pwd):/data osrm/osrm-backend osrm-routed --algorithm mld /data/berlin-latest.osrm
 
 Make requests against the HTTP server
 

docs/http.md

@@ -32,7 +32,6 @@ To pass parameters to each location some options support an array like encoding:
 |hints           |`{hint};{hint}[;{hint} ...]`                            |Hint from previous request to derive position in street network.                                       |
 |approaches      |`{approach};{approach}[;{approach} ...]`                |Keep waypoints on curb side.                                                                           |
 |exclude         |`{class}[,{class}]`                                     |Additive list of classes to avoid, order does not matter.                                              |
-|snapping        |`default` (default), `any`                              |Default snapping avoids is_startpoint (see profile) edges, `any` will snap to any edge in the graph    |
 
 Where the elements follow the following format:
 
@@ -71,8 +70,6 @@ curl 'http://router.project-osrm.org/route/v1/driving/polyline(ofp_Ik_vpAilAyu@t
 
 ### Responses
 
-#### Code
-
 Every response object has a `code` property containing one of the strings below or a service dependent code:
 
 | Type              | Description                                                                      |
@@ -90,17 +87,12 @@ Every response object has a `code` property containing one of the strings below
 - `message` is a **optional** human-readable error message. All other status types are service dependent.
 - In case of an error the HTTP status code will be `400`. Otherwise the HTTP status code will be `200` and `code` will be `Ok`.
 
-#### Data version
-
-Every response object has a `data_version` propetry containing timestamp from the original OpenStreetMap file. This field is optional. It can be ommited if data_version parametr was not set on osrm-extract stage or OSM file has not `osmosis_replication_timestamp` section.
-
 #### Example response
 
 ```json
 {
 "code": "Ok",
-"message": "Everything worked",
-"data_version": "2017-11-17T21:43:02Z"
+"message": "Everything worked"
 }
 ```
 

docs/nodejs/api.md

@@ -59,7 +59,6 @@ Returns the fastest route between two or more coordinates while visiting the way
     -   `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.waypoints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Indices to coordinates to treat as waypoints.  If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
                          `null`/`true`/`false`
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
@@ -92,7 +91,6 @@ 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`.
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
@@ -135,7 +133,6 @@ tables. Optionally returns distance table.
     -   `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.
     -   `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.
     -   `options.scale_factor` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Multiply the table duration values in the table by this number for more controlled input into a route optimization solver.
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
@@ -215,7 +212,6 @@ if they can not be matched successfully.
     -   `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`).
     -   `options.waypoints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Indices to coordinates to treat as waypoints.  If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**
@@ -280,7 +276,6 @@ 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`.
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**

features/car/startpoint.feature

@@ -35,91 +35,3 @@ Feature: Car - Allowed start/end modes
             | from | to | route | modes           |
             | 1    | 2  | ab,ab | driving,driving |
             | 2    | 1  | ab,ab | driving,driving |
-
-    Scenario: Car - URL override of non-startpoints
-        Given the node map
-            """
-            a 1 b   c 2 d
-            """
-
-        Given the query options
-            | snapping  | any          |
-
-        And the ways
-            | nodes | highway | access  |
-            | ab    | service | private |
-            | bc    | primary |         |
-            | cd    | service | private |
-
-        When I request a travel time matrix I should get
-            |   | 2    | c    |
-            | 1 | 59.1 | 35.1 |
-            | b | 35.1 | 11.1 |
-
-        When I route I should get
-            | from | to | route    |
-            | 1    | 2  | ab,bc,cd |
-            | 2    | 1  | cd,bc,ab |
-
-    Scenario: Car - URL override of non-startpoints
-        Given the node map
-            """
-            a 1 b   c 2 d
-            """
-
-        Given the query options
-            | snapping  | any          |
-            | bearings  | 90,180;      |
-
-        And the ways
-            | nodes | highway | access  |
-            | ab    | service | private |
-            | bc    | primary |         |
-            | cd    | service | private |
-
-        When I route I should get
-            | from | to | route    |
-            | 1    | 2  | ab,bc,cd |
-            | 2    | 1  | cd,bc,ab |
-
-    Scenario: Car - URL override of non-startpoints
-        Given the node map
-            """
-            a 1 b   c 2 d
-            """
-
-        Given the query options
-            | snapping  | any           |
-            | radiuses  | 100;unlimited |
-
-        And the ways
-            | nodes | highway | access  |
-            | ab    | service | private |
-            | bc    | primary |         |
-            | cd    | service | private |
-
-        When I route I should get
-            | from | to | route    |
-            | 1    | 2  | ab,bc,cd |
-            | 2    | 1  | cd,bc,ab |
-
-    Scenario: Car - URL override of non-startpoints
-        Given the node map
-            """
-            a 1 b   c 2 d
-            """
-
-        Given the query options
-            | snapping  | any            |
-            | bearings  | 90,180;0,180;; |
-
-        And the ways
-            | nodes | highway | access  |
-            | ab    | service | private |
-            | bc    | primary |         |
-            | cd    | service | private |
-
-        When I request a travel time matrix I should get
-            |   | 2    | c    |
-            | 1 | 59.1 | 35.1 |
-            | b | 35.1 | 11.1 |

features/support/shared_steps.js

@@ -75,10 +75,6 @@ module.exports = function () {
                             got.message = json.message || '';
                         }
 
-                        if (headers.has('data_version')) {
-                            got.data_version = json.data_version || '';
-                        }
-
                         if (headers.has('#')) {
                             // comment column
                             got['#'] = row['#'];

features/testbot/basic.feature

@@ -17,26 +17,9 @@ Feature: Basic Routing
             | ab    |
 
         When I route I should get
-            | from | to | route    | data_version |
-            | a    | b  | ab,ab    |              |
-            | b    | a  | ab,ab    |              |
-
-    Scenario: Data_version test
-        Given the node map
-            """
-            a b
-            """
-
-        And the extract extra arguments "--data_version cucumber_data_version"
-
-        And the ways
-            | nodes |
-            | ab    |
-
-        When I route I should get
-            | from | to | route    | data_version          |
-            | a    | b  | ab,ab    | cucumber_data_version |
-            | b    | a  | ab,ab    | cucumber_data_version |
+            | from | to | route    |
+            | a    | b  | ab,ab    |
+            | b    | a  | ab,ab    |
 
     Scenario: Routing in between two nodes of way
         Given the node map

include/engine/api/base_parameters.hpp

@@ -63,13 +63,6 @@ namespace api
  */
 struct BaseParameters
 {
-
-    enum class SnappingType
-    {
-        Default,
-        Any
-    };
-
     std::vector<util::Coordinate> coordinates;
     std::vector<boost::optional<Hint>> hints;
     std::vector<boost::optional<double>> radiuses;
@@ -80,19 +73,15 @@ struct BaseParameters
     // Adds hints to response which can be included in subsequent requests, see `hints` above.
     bool generate_hints = true;
 
-    SnappingType snapping = SnappingType::Default;
-
     BaseParameters(const std::vector<util::Coordinate> coordinates_ = {},
                    const std::vector<boost::optional<Hint>> hints_ = {},
                    std::vector<boost::optional<double>> radiuses_ = {},
                    std::vector<boost::optional<Bearing>> bearings_ = {},
                    std::vector<boost::optional<Approach>> approaches_ = {},
                    bool generate_hints_ = true,
-                   std::vector<std::string> exclude = {},
-                   const SnappingType snapping_ = SnappingType::Default)
+                   std::vector<std::string> exclude = {})
         : coordinates(coordinates_), hints(hints_), radiuses(radiuses_), bearings(bearings_),
-          approaches(approaches_), exclude(std::move(exclude)), generate_hints(generate_hints_),
-          snapping(snapping_)
+          approaches(approaches_), exclude(std::move(exclude)), generate_hints(generate_hints_)
     {
     }
 

include/engine/api/route_api.hpp

@@ -68,11 +68,6 @@ class RouteAPI : public BaseAPI
         response.values["waypoints"] = BaseAPI::MakeWaypoints(all_start_end_points);
         response.values["routes"] = std::move(jsRoutes);
         response.values["code"] = "Ok";
-        auto data_timestamp = facade.GetTimestamp();
-        if (!data_timestamp.empty())
-        {
-            response.values["data_version"] = data_timestamp;
-        }
     }
 
   protected:

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -137,7 +137,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     extractor::Datasources *m_datasources;
 
     std::uint32_t m_check_sum;
-    StringView m_data_timestamp;
     util::vector_view<util::Coordinate> m_coordinate_list;
     extractor::PackedOSMIDsView m_osmnodeid_list;
     util::vector_view<std::uint32_t> m_lane_description_offsets;
@@ -184,8 +183,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
         m_check_sum = *index.GetBlockPtr<std::uint32_t>("/common/connectivity_checksum");
 
-        m_data_timestamp = make_timestamp_view(index, "/common/timestamp");
-
         std::tie(m_coordinate_list, m_osmnodeid_list) =
             make_nbn_data_view(index, "/common/nbn_data");
 
@@ -389,25 +386,23 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const override final
+                                                      const Approach approach) const override final
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
         return m_geospatial_query->NearestPhantomNodeWithAlternativeFromBigComponent(
-            input_coordinate, approach, use_all_edges);
+            input_coordinate, approach);
     }
 
     std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
                                                       const double max_distance,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const override final
+                                                      const Approach approach) const override final
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
         return m_geospatial_query->NearestPhantomNodeWithAlternativeFromBigComponent(
-            input_coordinate, max_distance, approach, use_all_edges);
+            input_coordinate, max_distance, approach);
     }
 
     std::pair<PhantomNode, PhantomNode>
@@ -415,35 +410,28 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
                                                       const double max_distance,
                                                       const int bearing,
                                                       const int bearing_range,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const override final
+                                                      const Approach approach) const override final
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
         return m_geospatial_query->NearestPhantomNodeWithAlternativeFromBigComponent(
-            input_coordinate, max_distance, bearing, bearing_range, approach, use_all_edges);
+            input_coordinate, max_distance, bearing, bearing_range, approach);
     }
 
     std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
                                                       const int bearing,
                                                       const int bearing_range,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const override final
+                                                      const Approach approach) const override final
     {
         BOOST_ASSERT(m_geospatial_query.get());
 
         return m_geospatial_query->NearestPhantomNodeWithAlternativeFromBigComponent(
-            input_coordinate, bearing, bearing_range, approach, use_all_edges);
+            input_coordinate, bearing, bearing_range, approach);
     }
 
     std::uint32_t GetCheckSum() const override final { return m_check_sum; }
 
-    std::string GetTimestamp() const override final
-    {
-        return std::string(m_data_timestamp.begin(), m_data_timestamp.end());
-    }
-
     GeometryID GetGeometryIndex(const NodeID id) const override final
     {
         return edge_based_node_data.GetGeometryID(id);

include/engine/datafacade/datafacade_base.hpp

@@ -74,8 +74,6 @@ class BaseDataFacade
 
     virtual std::uint32_t GetCheckSum() const = 0;
 
-    virtual std::string GetTimestamp() const = 0;
-
     // node and edge information access
     virtual util::Coordinate GetCoordinateOfNode(const NodeID id) const = 0;
 
@@ -161,26 +159,22 @@ class BaseDataFacade
 
     virtual std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const = 0;
+                                                      const Approach approach) const = 0;
     virtual std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
                                                       const double max_distance,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const = 0;
+                                                      const Approach approach) const = 0;
     virtual std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
                                                       const double max_distance,
                                                       const int bearing,
                                                       const int bearing_range,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const = 0;
+                                                      const Approach approach) const = 0;
     virtual std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
                                                       const int bearing,
                                                       const int bearing_range,
-                                                      const Approach approach,
-                                                      const bool use_all_edges = false) const = 0;
+                                                      const Approach approach) const = 0;
 
     virtual bool HasLaneData(const EdgeID id) const = 0;
     virtual util::guidance::LaneTupleIdPair GetLaneData(const EdgeID id) const = 0;

include/engine/geospatial_query.hpp

@@ -205,23 +205,18 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
                                                       const double max_distance,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const
+                                                      const Approach approach) const
     {
         bool has_small_component = false;
         bool has_big_component = false;
         auto results = rtree.Nearest(
             input_coordinate,
-            [this,
-             approach,
-             &input_coordinate,
-             &has_big_component,
-             &has_small_component,
-             &use_all_edges](const CandidateSegment &segment) {
+            [this, approach, &input_coordinate, &has_big_component, &has_small_component](
+                const CandidateSegment &segment) {
                 auto use_segment =
                     (!has_small_component || (!has_big_component && !IsTinyComponent(segment)));
                 auto use_directions = std::make_pair(use_segment, use_segment);
-                const auto valid_edges = HasValidEdge(segment, use_all_edges);
+                const auto valid_edges = HasValidEdge(segment);
                 const auto admissible_segments = CheckSegmentExclude(segment);
                 use_directions = boolPairAnd(use_directions, admissible_segments);
                 use_directions = boolPairAnd(use_directions, valid_edges);
@@ -256,24 +251,19 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     // a second phantom node is return that is the nearest coordinate in a big component.
     std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const
+                                                      const Approach approach) const
     {
         bool has_small_component = false;
         bool has_big_component = false;
         auto results = rtree.Nearest(
             input_coordinate,
-            [this,
-             approach,
-             &input_coordinate,
-             &has_big_component,
-             &has_small_component,
-             &use_all_edges](const CandidateSegment &segment) {
+            [this, approach, &input_coordinate, &has_big_component, &has_small_component](
+                const CandidateSegment &segment) {
                 auto use_segment =
                     (!has_small_component || (!has_big_component && !IsTinyComponent(segment)));
                 auto use_directions = std::make_pair(use_segment, use_segment);
 
-                const auto valid_edges = HasValidEdge(segment, use_all_edges);
+                const auto valid_edges = HasValidEdge(segment);
                 const auto admissible_segments = CheckSegmentExclude(segment);
                 use_directions = boolPairAnd(use_directions, admissible_segments);
                 use_directions = boolPairAnd(use_directions, valid_edges);
@@ -308,8 +298,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
                                                       const int bearing,
                                                       const int bearing_range,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const
+                                                      const Approach approach) const
     {
         bool has_small_component = false;
         bool has_big_component = false;
@@ -321,18 +310,18 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
              bearing,
              bearing_range,
              &has_big_component,
-             &has_small_component,
-             &use_all_edges](const CandidateSegment &segment) {
+             &has_small_component](const CandidateSegment &segment) {
                 auto use_segment =
                     (!has_small_component || (!has_big_component && !IsTinyComponent(segment)));
                 auto use_directions = std::make_pair(use_segment, use_segment);
                 const auto admissible_segments = CheckSegmentExclude(segment);
+                use_directions = boolPairAnd(use_directions, HasValidEdge(segment));
 
                 if (use_segment)
                 {
                     use_directions =
                         boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range),
-                                    HasValidEdge(segment, use_all_edges));
+                                    HasValidEdge(segment));
                     use_directions = boolPairAnd(use_directions, admissible_segments);
                     use_directions = boolPairAnd(
                         use_directions, CheckApproach(input_coordinate, segment, approach));
@@ -367,8 +356,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                                                       const double max_distance,
                                                       const int bearing,
                                                       const int bearing_range,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const
+                                                      const Approach approach) const
     {
         bool has_small_component = false;
         bool has_big_component = false;
@@ -380,18 +368,18 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
              bearing,
              bearing_range,
              &has_big_component,
-             &has_small_component,
-             &use_all_edges](const CandidateSegment &segment) {
+             &has_small_component](const CandidateSegment &segment) {
                 auto use_segment =
                     (!has_small_component || (!has_big_component && !IsTinyComponent(segment)));
                 auto use_directions = std::make_pair(use_segment, use_segment);
                 const auto admissible_segments = CheckSegmentExclude(segment);
+                use_directions = boolPairAnd(use_directions, HasValidEdge(segment));
 
                 if (use_segment)
                 {
                     use_directions =
                         boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range),
-                                    HasValidEdge(segment, use_all_edges));
+                                    HasValidEdge(segment));
                     use_directions = boolPairAnd(use_directions, admissible_segments);
                     use_directions = boolPairAnd(
                         use_directions, CheckApproach(input_coordinate, segment, approach));

include/engine/plugins/plugin_base.hpp

@@ -270,7 +270,6 @@ class BasePlugin
         const bool use_bearings = !parameters.bearings.empty();
         const bool use_radiuses = !parameters.radiuses.empty();
         const bool use_approaches = !parameters.approaches.empty();
-        const bool use_all_edges = parameters.snapping == api::BaseParameters::SnappingType::Any;
 
         BOOST_ASSERT(parameters.IsValid());
         for (const auto i : util::irange<std::size_t>(0UL, parameters.coordinates.size()))
@@ -297,8 +296,7 @@ class BasePlugin
                             *parameters.radiuses[i],
                             parameters.bearings[i]->bearing,
                             parameters.bearings[i]->range,
-                            approach,
-                            use_all_edges);
+                            approach);
                 }
                 else
                 {
@@ -307,8 +305,7 @@ class BasePlugin
                             parameters.coordinates[i],
                             parameters.bearings[i]->bearing,
                             parameters.bearings[i]->range,
-                            approach,
-                            use_all_edges);
+                            approach);
                 }
             }
             else
@@ -317,16 +314,13 @@ class BasePlugin
                 {
                     phantom_node_pairs[i] =
                         facade.NearestPhantomNodeWithAlternativeFromBigComponent(
-                            parameters.coordinates[i],
-                            *parameters.radiuses[i],
-                            approach,
-                            use_all_edges);
+                            parameters.coordinates[i], *parameters.radiuses[i], approach);
                 }
                 else
                 {
                     phantom_node_pairs[i] =
                         facade.NearestPhantomNodeWithAlternativeFromBigComponent(
-                            parameters.coordinates[i], approach, use_all_edges);
+                            parameters.coordinates[i], approach);
                 }
             }
 

include/extractor/extractor_config.hpp

@@ -55,7 +55,6 @@ struct ExtractorConfig final : storage::IOConfig
                                       ".osrm.geometry",
                                       ".osrm.nbg_nodes",
                                       ".osrm.ebg_nodes",
-                                      ".osrm.timestamp",
                                       ".osrm.edges",
                                       ".osrm.ebg",
                                       ".osrm.ramIndex",
@@ -83,7 +82,6 @@ struct ExtractorConfig final : storage::IOConfig
     boost::filesystem::path input_path;
     boost::filesystem::path profile_path;
     std::vector<boost::filesystem::path> location_dependent_data_paths;
-    std::string data_version;
 
     unsigned requested_num_threads;
     unsigned small_component_size;

include/extractor/files.hpp

@@ -308,26 +308,6 @@ inline void writeTurnLaneData(const boost::filesystem::path &path,
     storage::serialization::write(writer, "/common/turn_lanes/data", turn_lane_data);
 }
 
-// reads .osrm.timestamp
-template <typename TimestampDataT>
-inline void readTimestamp(const boost::filesystem::path &path, TimestampDataT &timestamp)
-{
-    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
-    storage::tar::FileReader reader{path, fingerprint};
-
-    storage::serialization::read(reader, "/common/timestamp", timestamp);
-}
-
-// writes .osrm.timestamp
-template <typename TimestampDataT>
-inline void writeTimestamp(const boost::filesystem::path &path, const TimestampDataT &timestamp)
-{
-    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
-    storage::tar::FileWriter writer{path, fingerprint};
-
-    storage::serialization::write(writer, "/common/timestamp", timestamp);
-}
-
 // reads .osrm.maneuver_overrides
 template <typename StorageManeuverOverrideT, typename NodeSequencesT>
 inline void readManeuverOverrides(const boost::filesystem::path &path,

include/nodejs/node_osrm_support.hpp

@@ -1010,35 +1010,6 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         }
     }
 
-    if (obj->Has(Nan::New("snapping").ToLocalChecked()))
-    {
-        v8::Local<v8::Value> snapping = obj->Get(Nan::New("snapping").ToLocalChecked());
-        if (snapping.IsEmpty())
-            return route_parameters_ptr();
-
-        if (!snapping->IsString())
-        {
-            Nan::ThrowError("Snapping must be a string: [default, any]");
-            return route_parameters_ptr();
-        }
-        const Nan::Utf8String snapping_utf8str(snapping);
-        std::string snapping_str{*snapping_utf8str, *snapping_utf8str + snapping_utf8str.length()};
-
-        if (snapping_str == "default")
-        {
-            params->snapping = osrm::RouteParameters::SnappingType::Default;
-        }
-        else if (snapping_str == "any")
-        {
-            params->snapping = osrm::RouteParameters::SnappingType::Any;
-        }
-        else
-        {
-            Nan::ThrowError("'snapping' param must be one of [default, any]");
-            return route_parameters_ptr();
-        }
-    }
-
     bool parsedSuccessfully = parseCommonParameters(obj, params);
     if (!parsedSuccessfully)
     {

include/server/api/base_parameters_grammar.hpp

@@ -162,13 +162,6 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
                         (-approach_type %
                          ';')[ph::bind(&engine::api::BaseParameters::approaches, qi::_r1) = qi::_1];
 
-        snapping_type.add("default", engine::api::BaseParameters::SnappingType::Default)(
-            "any", engine::api::BaseParameters::SnappingType::Any);
-
-        snapping_rule =
-            qi::lit("snapping=") >
-            snapping_type[ph::bind(&engine::api::BaseParameters::snapping, qi::_r1) = qi::_1];
-
         exclude_rule = qi::lit("exclude=") >
                        (qi::as_string[+qi::char_("a-zA-Z0-9")] %
                         ',')[ph::bind(&engine::api::BaseParameters::exclude, qi::_r1) = qi::_1];
@@ -178,8 +171,7 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
                     | bearings_rule(qi::_r1)       //
                     | generate_hints_rule(qi::_r1) //
                     | approach_rule(qi::_r1)       //
-                    | exclude_rule(qi::_r1)        //
-                    | snapping_rule(qi::_r1);
+                    | exclude_rule(qi::_r1);
     }
 
   protected:
@@ -205,10 +197,8 @@ 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::rule<Iterator, Signature> snapping_rule;
 
     qi::symbols<char, engine::Approach> approach_type;
-    qi::symbols<char, engine::api::BaseParameters::SnappingType> snapping_type;
 };
 }
 }

include/storage/storage_config.hpp

@@ -58,7 +58,6 @@ struct StorageConfig final : IOConfig
                     ".osrm.turn_duration_penalties",
                     ".osrm.datasource_names",
                     ".osrm.names",
-                    ".osrm.timestamp",
                     ".osrm.properties",
                     ".osrm.icd",
                     ".osrm.maneuver_overrides"},

include/storage/view_factory.hpp

@@ -272,11 +272,6 @@ inline auto make_partition_view(const SharedDataIndex &index, const std::string
         level_data_ptr, std::move(partition), std::move(cell_to_children)};
 }
 
-inline auto make_timestamp_view(const SharedDataIndex &index, const std::string &name)
-{
-    return util::StringView(index.GetBlockPtr<char>(name), index.GetBlockEntries(name));
-}
-
 inline auto make_cell_storage_view(const SharedDataIndex &index, const std::string &name)
 {
     auto source_boundary = make_vector_view<NodeID>(index, name + "/source_boundary");

include/util/typedefs.hpp

@@ -79,7 +79,6 @@ using EdgeDistance = float;
 using SegmentWeight = std::uint32_t;
 using SegmentDuration = std::uint32_t;
 using TurnPenalty = std::int16_t; // turn penalty in 100ms units
-using DataTimestamp = std::string;
 
 static const std::size_t INVALID_INDEX = std::numeric_limits<std::size_t>::max();
 

package.json

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

profiles/car.lua

@@ -60,8 +60,7 @@ function setup()
       'lift_gate',
       'no',
       'entrance',
-      'height_restrictor',
-      'arch'
+      'height_restrictor'
     },
 
     access_tag_whitelist = Set {

src/extractor/extractor.cpp

@@ -51,7 +51,6 @@
 #include <osmium/handler/node_locations_for_ways.hpp>
 #include <osmium/index/map/flex_mem.hpp>
 #include <osmium/io/any_input.hpp>
-#include <osmium/osm/timestamp.hpp>
 #include <osmium/thread/pool.hpp>
 #include <osmium/visitor.hpp>
 
@@ -426,14 +425,6 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
 
         // write .timestamp data file
         std::string timestamp = header.get("osmosis_replication_timestamp");
-        if (config.data_version == "osmosis")
-        {
-            files::writeTimestamp(config.GetPath(".osrm.timestamp").string(), timestamp);
-        }
-        else
-        {
-            files::writeTimestamp(config.GetPath(".osrm.timestamp").string(), config.data_version);
-        }
         if (timestamp.empty())
         {
             timestamp = "n/a";

src/storage/storage.cpp

@@ -302,7 +302,6 @@ std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetStaticFiles()
         {REQUIRED, config.GetPath(".osrm.ebg_nodes")},
         {REQUIRED, config.GetPath(".osrm.tls")},
         {REQUIRED, config.GetPath(".osrm.tld")},
-        {REQUIRED, config.GetPath(".osrm.timestamp")},
         {REQUIRED, config.GetPath(".osrm.maneuver_overrides")},
         {REQUIRED, config.GetPath(".osrm.edges")},
         {REQUIRED, config.GetPath(".osrm.names")},
@@ -402,17 +401,6 @@ void Storage::PopulateStaticData(const SharedDataIndex &index)
         extractor::files::readNames(config.GetPath(".osrm.names"), name_table);
     }
 
-    // Timestamp mark
-    {
-        auto timestamp_ref = make_timestamp_view(index, "/common/timestamp");
-        std::string ts;
-        extractor::files::readTimestamp(config.GetPath(".osrm.timestamp"), ts);
-        if (!ts.empty())
-        {
-            memcpy(const_cast<char *>(timestamp_ref.data()), ts.data(), ts.size());
-        }
-    }
-
     // Turn lane data
     {
         auto turn_lane_data = make_lane_data_view(index, "/common/turn_lanes");

src/tools/extract.cpp

@@ -43,10 +43,6 @@ return_code parseArguments(int argc,
         boost::program_options::value<boost::filesystem::path>(&extractor_config.profile_path)
             ->default_value("profiles/car.lua"),
         "Path to LUA routing profile")(
-        "data_version,d",
-        boost::program_options::value<std::string>(&extractor_config.data_version)
-            ->default_value(""),
-        "Data version. Leave blank to avoid. osmosis - to get timestamp from file")(
         "threads,t",
         boost::program_options::value<unsigned int>(&extractor_config.requested_num_threads)
             ->default_value(tbb::task_scheduler_init::default_num_threads()),

taginfo.json

@@ -6,8 +6,8 @@
         "description": "High-performance routing engine for shortest paths in road networks.",
         "project_url": "http://project-osrm.org",
         "icon_url": "http://project-osrm.org/images/osrm_icon.png",
-        "contact_name": "Daniel Patterson",
-        "contact_email": "daniel@mapbox.com"
+        "contact_name": "Patrick Niklaus",
+        "contact_email": "patrick@mapbox.com"
     },
     "tags": [
         {

test/nodejs/route.js

@@ -689,25 +689,4 @@ test('route: throws on invalid waypoints values, waypoints must be an array of i
     };
     assert.throws(function () { osrm.route(options, function (err, response) { console.error(`response: ${response}`); console.error(`error: ${err}`); }); },
         /Waypoints must be supplied in increasing order/);
-});
-
-test('route: throws on invalid snapping values', function (assert) {
-    assert.plan(1);
-    var osrm = new OSRM(monaco_path);
-    var options = {
-        steps: true,
-        coordinates: three_test_coordinates.concat(three_test_coordinates),
-        snapping: "zing"
-    };
-    assert.throws(function () { osrm.route(options, function (err, response) { console.error(`response: ${response}`); console.error(`error: ${err}`); }); },
-        /'snapping' param must be one of \[default, any\]/);
-});
-
-test('route: snapping parameter passed through OK', function(assert) {
-    assert.plan(2);
-    var osrm = new OSRM(monaco_path);
-    osrm.route({snapping: "any", coordinates: [[7.448205209414596,43.754001097311544],[7.447122039202185,43.75306156811368]]}, function(err, route) {
-        assert.ifError(err);
-        assert.equal(Math.round(route.routes[0].distance * 10), 1314); // Round it to nearest 0.1m to eliminate floating point comparison error
-    });
 });

unit_tests/engine/offline_facade.cpp

@@ -284,8 +284,7 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
 
     std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/,
-                                                      const Approach /*approach*/,
-                                                      const bool /* use_all_edges */) const override
+                                                      const Approach /*approach*/) const override
     {
         return {};
     }
@@ -293,8 +292,7 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     std::pair<PhantomNode, PhantomNode>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/,
                                                       const double /*max_distance*/,
-                                                      const Approach /*approach*/,
-                                                      const bool /* use_all_edges */) const override
+                                                      const Approach /*approach*/) const override
     {
         return {};
     }
@@ -304,8 +302,7 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
                                                       const double /*max_distance*/,
                                                       const int /*bearing*/,
                                                       const int /*bearing_range*/,
-                                                      const Approach /*approach*/,
-                                                      const bool /* use_all_edges */) const override
+                                                      const Approach /*approach*/) const override
     {
         return {};
     }
@@ -314,8 +311,7 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/,
                                                       const int /*bearing*/,
                                                       const int /*bearing_range*/,
-                                                      const Approach /*approach*/,
-                                                      const bool /* use_all_edges */) const override
+                                                      const Approach /*approach*/) const override
     {
         return {};
     }
@@ -345,7 +341,6 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     StringView GetDestinationsForID(const NameID /*id*/) const override { return StringView{}; }
     StringView GetExitsForID(const NameID /*id*/) const override { return StringView{}; }
     bool GetContinueStraightDefault() const override { return false; }
-    std::string GetTimestamp() const override { return ""; }
     double GetMapMatchingMaxSpeed() const override { return 0; }
     const char *GetWeightName() const override { return ""; }
     unsigned GetWeightPrecision() const override { return 0; }

unit_tests/mocks/mock_datafacade.hpp

@@ -10,6 +10,7 @@
 #include "extractor/turn_lane_types.hpp"
 #include "guidance/turn_bearing.hpp"
 #include "guidance/turn_instruction.hpp"
+#include "guidance/turn_instruction.hpp"
 
 #include "engine/algorithm.hpp"
 #include "engine/datafacade/algorithm_datafacade.hpp"
@@ -53,7 +54,6 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     {
         return 0;
     }
-    std::string GetTimestamp() const override { return ""; }
     NodeForwardRange GetUncompressedForwardGeometry(const EdgeID /* id */) const override
     {
         static NodeID data[] = {0, 1, 2, 3};
@@ -167,39 +167,39 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     }
 
     std::pair<engine::PhantomNode, engine::PhantomNode>
-    NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/,
-                                                      const engine::Approach /*approach*/,
-                                                      const bool /* use_all_edges */) const override
+    NearestPhantomNodeWithAlternativeFromBigComponent(
+        const util::Coordinate /*input_coordinate*/,
+        const engine::Approach /*approach*/) const override
     {
         return {};
     }
 
     std::pair<engine::PhantomNode, engine::PhantomNode>
-    NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/,
-                                                      const double /*max_distance*/,
-                                                      const engine::Approach /*approach*/,
-                                                      const bool /* use_all_edges */) const override
+    NearestPhantomNodeWithAlternativeFromBigComponent(
+        const util::Coordinate /*input_coordinate*/,
+        const double /*max_distance*/,
+        const engine::Approach /*approach*/) const override
     {
         return {};
     }
 
     std::pair<engine::PhantomNode, engine::PhantomNode>
-    NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/,
-                                                      const double /*max_distance*/,
-                                                      const int /*bearing*/,
-                                                      const int /*bearing_range*/,
-                                                      const engine::Approach /*approach*/,
-                                                      const bool /* use_all_edges */) const override
+    NearestPhantomNodeWithAlternativeFromBigComponent(
+        const util::Coordinate /*input_coordinate*/,
+        const double /*max_distance*/,
+        const int /*bearing*/,
+        const int /*bearing_range*/,
+        const engine::Approach /*approach*/) const override
     {
         return {};
     }
 
     std::pair<engine::PhantomNode, engine::PhantomNode>
-    NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate /*input_coordinate*/,
-                                                      const int /*bearing*/,
-                                                      const int /*bearing_range*/,
-                                                      const engine::Approach /*approach*/,
-                                                      const bool /* use_all_edges */) const override
+    NearestPhantomNodeWithAlternativeFromBigComponent(
+        const util::Coordinate /*input_coordinate*/,
+        const int /*bearing*/,
+        const int /*bearing_range*/,
+        const engine::Approach /*approach*/) const override
     {
         return {};
     }