Build tags with semver metadata.

.travis.yml

@@ -14,7 +14,7 @@ branches:
   only:
     - master
     # enable building tags
-    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
+    - /^v\d+\.\d+(\.\d+)?(\+[^-]+)?(-\S*)?$/
 
 cache:
   npm: true

CHANGELOG.md

@@ -5,9 +5,6 @@
     - 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:
 

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

@@ -51,75 +51,7 @@ Feature: Car - Allowed start/end modes
             | 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 |

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_parameters.hpp

@@ -78,6 +78,11 @@ struct RouteParameters : public BaseParameters
         Speed = 0x20,
         All = Duration | Nodes | Distance | Weight | Datasources | Speed
     };
+    enum class SnappingType
+    {
+        Default,
+        Any
+    };
 
     RouteParameters() = default;
 
@@ -147,12 +152,13 @@ struct RouteParameters : public BaseParameters
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
                     std::vector<std::size_t> waypoints_,
+                    const SnappingType snapping_,
                     const Args... args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
           annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
           geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},
-          waypoints{waypoints_}
+          waypoints{waypoints_}, snapping{snapping_}
     {
     }
 
@@ -165,12 +171,13 @@ struct RouteParameters : public BaseParameters
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
                     std::vector<std::size_t> waypoints_,
+                    const SnappingType snapping_,
                     Args... args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u},
           annotations{annotations_ == AnnotationsType::None ? false : true},
           annotations_type{annotations_}, geometries{geometries_}, overview{overview_},
-          continue_straight{continue_straight_}, waypoints{waypoints_}
+          continue_straight{continue_straight_}, waypoints{waypoints_}, snapping{snapping_}
     {
     }
 
@@ -184,6 +191,7 @@ struct RouteParameters : public BaseParameters
     OverviewType overview = OverviewType::Simplified;
     boost::optional<bool> continue_straight;
     std::vector<std::size_t> waypoints;
+    SnappingType snapping = SnappingType::Default;
 
     bool IsValid() const
     {

include/engine/geospatial_query.hpp

@@ -327,12 +327,13 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                     (!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, use_all_edges));
 
                 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));
@@ -386,12 +387,13 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                     (!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, use_all_edges));
 
                 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

@@ -262,7 +262,8 @@ class BasePlugin
     }
 
     std::vector<PhantomNodePair> GetPhantomNodes(const datafacade::BaseDataFacade &facade,
-                                                 const api::BaseParameters &parameters) const
+                                                 const api::BaseParameters &parameters,
+                                                 const bool use_all_edges = false) const
     {
         std::vector<PhantomNodePair> phantom_node_pairs(parameters.coordinates.size());
 
@@ -270,7 +271,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()))

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/server/api/route_parameters_grammar.hpp

@@ -82,6 +82,9 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
             qi::lit("waypoints=") >
             (size_t_ % ';')[ph::bind(&engine::api::RouteParameters::waypoints, qi::_r1) = qi::_1];
 
+        snapping_type.add("default", engine::api::RouteParameters::SnappingType::Default)(
+            "any", engine::api::RouteParameters::SnappingType::Any);
+
         base_rule =
             BaseGrammar::base_rule(qi::_r1) | waypoints_rule(qi::_r1) |
             (qi::lit("steps=") >
@@ -91,6 +94,8 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
                                  qi::_1]) |
             (qi::lit("overview=") >
              overview_type[ph::bind(&engine::api::RouteParameters::overview, qi::_r1) = qi::_1]) |
+            (qi::lit("snapping=") >
+             snapping_type[ph::bind(&engine::api::RouteParameters::snapping, qi::_r1) = qi::_1]) |
             (qi::lit("annotations=") >
              (qi::lit("true")[ph::bind(add_annotation, qi::_r1, AnnotationsType::All)] |
               qi::lit("false")[ph::bind(add_annotation, qi::_r1, AnnotationsType::None)] |
@@ -112,6 +117,7 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
     qi::symbols<char, engine::api::RouteParameters::GeometriesType> geometries_type;
     qi::symbols<char, engine::api::RouteParameters::OverviewType> overview_type;
     qi::symbols<char, engine::api::RouteParameters::AnnotationsType> annotations_type;
+    qi::symbols<char, engine::api::RouteParameters::SnappingType> snapping_type;
 };
 }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "osrm",
-  "version": "5.22.0-customsnapping.3",
+  "version": "5.22.0+customsnapping.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/engine/plugins/viaroute.cpp

@@ -87,7 +87,10 @@ Status ViaRoutePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithm
         return Status::Error;
 
     const auto &facade = algorithms.GetFacade();
-    auto phantom_node_pairs = GetPhantomNodes(facade, route_parameters);
+    auto phantom_node_pairs =
+        GetPhantomNodes(facade,
+                        route_parameters,
+                        (route_parameters.snapping == api::RouteParameters::SnappingType::Any));
     if (phantom_node_pairs.size() != route_parameters.coordinates.size())
     {
         return Error("NoSegment",

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": [
         {

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 {};
     }

unit_tests/mocks/mock_datafacade.hpp

@@ -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 {};
     }