Lifts restriction to only provide zero or one alternative routes

include/engine/api/route_api.hpp

@@ -41,27 +41,33 @@ class RouteAPI : public BaseAPI
     {
     }
 
+    void MakeResponse(const InternalManyRoutesResult &raw_routes,
+                      util::json::Object &response) const
+    {
+        BOOST_ASSERT(!raw_routes.routes.empty());
+
+        util::json::Array jsRoutes;
+
+        for (const auto &route : raw_routes.routes)
+        {
+            if (!route.is_valid())
+                continue;
+
+            jsRoutes.values.push_back(MakeRoute(route.segment_end_coordinates,
+                                                route.unpacked_path_segments,
+                                                route.source_traversed_in_reverse,
+                                                route.target_traversed_in_reverse));
+        }
+
+        response.values["waypoints"] =
+            BaseAPI::MakeWaypoints(raw_routes.routes[0].segment_end_coordinates);
+        response.values["routes"] = std::move(jsRoutes);
+        response.values["code"] = "Ok";
+    }
+
     void MakeResponse(const InternalRouteResult &raw_route, util::json::Object &response) const
     {
-        auto number_of_routes = raw_route.has_alternative() ? 2UL : 1UL;
-        util::json::Array routes;
-        routes.values.resize(number_of_routes);
-        routes.values[0] = MakeRoute(raw_route.segment_end_coordinates,
-                                     raw_route.unpacked_path_segments,
-                                     raw_route.source_traversed_in_reverse,
-                                     raw_route.target_traversed_in_reverse);
-        if (raw_route.has_alternative())
-        {
-            std::vector<std::vector<PathData>> wrapped_leg(1);
-            wrapped_leg.front() = std::move(raw_route.unpacked_alternative);
-            routes.values[1] = MakeRoute(raw_route.segment_end_coordinates,
-                                         wrapped_leg,
-                                         raw_route.alt_source_traversed_in_reverse,
-                                         raw_route.alt_target_traversed_in_reverse);
-        }
-        response.values["waypoints"] = BaseAPI::MakeWaypoints(raw_route.segment_end_coordinates);
-        response.values["routes"] = std::move(routes);
-        response.values["code"] = "Ok";
+        return MakeResponse(raw_route, response);
     }
 
   protected:

include/engine/internal_route_result.hpp

@@ -47,24 +47,29 @@ struct PathData
 struct InternalRouteResult
 {
     std::vector<std::vector<PathData>> unpacked_path_segments;
-    std::vector<PathData> unpacked_alternative;
     std::vector<PhantomNodes> segment_end_coordinates;
     std::vector<bool> source_traversed_in_reverse;
     std::vector<bool> target_traversed_in_reverse;
-    std::vector<bool> alt_source_traversed_in_reverse;
-    std::vector<bool> alt_target_traversed_in_reverse;
     EdgeWeight shortest_path_weight = INVALID_EDGE_WEIGHT;
-    EdgeWeight alternative_path_weight = INVALID_EDGE_WEIGHT;
 
     bool is_valid() const { return INVALID_EDGE_WEIGHT != shortest_path_weight; }
 
-    bool has_alternative() const { return INVALID_EDGE_WEIGHT != alternative_path_weight; }
-
     bool is_via_leg(const std::size_t leg) const
     {
         return (leg != unpacked_path_segments.size() - 1);
     }
 };
+
+struct InternalManyRoutesResult
+{
+    InternalManyRoutesResult() = default;
+    InternalManyRoutesResult(InternalRouteResult route) : routes{std::move(route)} {}
+    InternalManyRoutesResult(std::vector<InternalRouteResult> routes_) : routes{std::move(routes_)}
+    {
+    }
+
+    std::vector<InternalRouteResult> routes;
+};
 }
 }
 

include/engine/routing_algorithms.hpp

@@ -19,7 +19,7 @@ namespace engine
 class RoutingAlgorithmsInterface
 {
   public:
-    virtual InternalRouteResult
+    virtual InternalManyRoutesResult
     AlternativePathSearch(const PhantomNodes &phantom_node_pair) const = 0;
 
     virtual InternalRouteResult
@@ -65,7 +65,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
 
     virtual ~RoutingAlgorithms() = default;
 
-    InternalRouteResult
+    InternalManyRoutesResult
     AlternativePathSearch(const PhantomNodes &phantom_node_pair) const final override;
 
     InternalRouteResult ShortestPathSearch(
@@ -129,7 +129,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
 };
 
 template <typename Algorithm>
-InternalRouteResult
+InternalManyRoutesResult
 RoutingAlgorithms<Algorithm>::AlternativePathSearch(const PhantomNodes &phantom_node_pair) const
 {
     return routing_algorithms::ch::alternativePathSearch(heaps, facade, phantom_node_pair);
@@ -188,7 +188,7 @@ inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<Algorithm>::G
 
 // CoreCH overrides
 template <>
-InternalRouteResult inline RoutingAlgorithms<
+InternalManyRoutesResult inline RoutingAlgorithms<
     routing_algorithms::corech::Algorithm>::AlternativePathSearch(const PhantomNodes &) const
 {
     throw util::exception("AlternativePathSearch is disabled due to performance reasons");
@@ -206,7 +206,7 @@ RoutingAlgorithms<routing_algorithms::corech::Algorithm>::ManyToManySearch(
 
 // MLD overrides for not implemented
 template <>
-InternalRouteResult inline RoutingAlgorithms<
+InternalManyRoutesResult inline RoutingAlgorithms<
     routing_algorithms::mld::Algorithm>::AlternativePathSearch(const PhantomNodes &) const
 {
     throw util::exception("AlternativePathSearch is not implemented");

include/engine/routing_algorithms/alternative_path.hpp

@@ -17,7 +17,7 @@ namespace routing_algorithms
 {
 namespace ch
 {
-InternalRouteResult
+InternalManyRoutesResult
 alternativePathSearch(SearchEngineData<Algorithm> &search_engine_data,
                       const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                       const PhantomNodes &phantom_node_pair);