Add type traits to disable plugins for specific algorithms

include/engine/algorithm.hpp

@@ -1,6 +1,8 @@
 #ifndef OSRM_ENGINE_ALGORITHM_HPP
 #define OSRM_ENGINE_ALGORITHM_HPP
 
+#include <type_traits>
+
 namespace osrm
 {
 namespace engine
@@ -9,27 +11,29 @@ namespace algorithm
 {
 
 // Contraction Hiearchy
-struct CH;
+struct CH final {};
+// Contraction Hiearchy with core
+struct CoreCH final {};
+
 }
 
 namespace algorithm_trais
 {
-template <typename AlgorithmT> struct HasAlternativeRouting final
-{
-    template <template <typename A> class FacadeT> bool operator()(const FacadeT<AlgorithmT> &)
-    {
-        return false;
-    }
-};
 
-template <> struct HasAlternativeRouting<algorithm::CH> final
+template <typename AlgorithmT> struct HasAlternativePathSearch final : std::false_type {};
-{
+template <typename AlgorithmT> struct HasShortestPathSearch final : std::false_type {};
-    template <template <typename A> class FacadeT>
+template <typename AlgorithmT> struct HasDirectShortestPathSearch final : std::false_type {};
-    bool operator()(const FacadeT<algorithm::CH> &facade)
+template <typename AlgorithmT> struct HasMapMatching final : std::false_type {};
-    {
+template <typename AlgorithmT> struct HasManyToManySearch final : std::false_type {};
-        return facade.GetCoreSize() == 0;
+template <typename AlgorithmT> struct HasGetTileTurns final : std::false_type {};
-    }
+
-};
+template <> struct HasAlternativePathSearch<algorithm::CH> final : std::true_type {};
+template <> struct HasShortestPathSearch<algorithm::CH> final : std::true_type {};
+template <> struct HasDirectShortestPathSearch<algorithm::CH> final : std::true_type {};
+template <> struct HasMapMatching<algorithm::CH> final : std::true_type {};
+template <> struct HasManyToManySearch<algorithm::CH> final : std::true_type {};
+template <> struct HasGetTileTurns<algorithm::CH> final : std::true_type {};
+
 }
 }
 }

include/engine/routing_algorithms.hpp

@@ -19,17 +19,17 @@ namespace engine
 class RoutingAlgorithmsInterface
 {
   public:
-    virtual InternalRouteResult AlternativeRouting(const PhantomNodes &phantom_node_pair) const = 0;
+    virtual InternalRouteResult AlternativePathSearch(const PhantomNodes &phantom_node_pair) const = 0;
 
     virtual InternalRouteResult
-    ShortestRouting(const std::vector<PhantomNodes> &phantom_node_pair,
+    ShortestPathSearch(const std::vector<PhantomNodes> &phantom_node_pair,
                     const boost::optional<bool> continue_straight_at_waypoint) const = 0;
 
     virtual InternalRouteResult
-    DirectShortestPathRouting(const std::vector<PhantomNodes> &phantom_node_pair) const = 0;
+    DirectShortestPathSearch(const std::vector<PhantomNodes> &phantom_node_pair) const = 0;
 
     virtual std::vector<EdgeWeight>
-    ManyToManyRouting(const std::vector<PhantomNode> &phantom_nodes,
+    ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
                       const std::vector<std::size_t> &source_indices,
                       const std::vector<std::size_t> &target_indices) const = 0;
 
@@ -40,12 +40,24 @@ class RoutingAlgorithmsInterface
                 const std::vector<boost::optional<double>> &trace_gps_precision) const = 0;
 
     virtual std::vector<routing_algorithms::TurnData>
-    TileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
+    GetTileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
               const std::vector<std::size_t> &sorted_edge_indexes) const = 0;
 
-    virtual bool HasAlternativeRouting() const = 0;
+    virtual bool HasAlternativePathSearch() const = 0;
+    virtual bool HasShortestPathSearch() const = 0;
+    virtual bool HasDirectShortestPathSearch() const = 0;
+    virtual bool HasMapMatching() const = 0;
+    virtual bool HasManyToManySearch() const = 0;
+    virtual bool HasGetTileTurns() const = 0;
 };
 
+namespace detail
+{
+
+struct NotImplementedException : public std::runtime_error {};
+
+}
+
 // Short-lived object passed to each plugin in request to wrap routing algorithms
 template <typename AlgorithmT> class RoutingAlgorithms final : public RoutingAlgorithmsInterface
 {
@@ -57,27 +69,27 @@ template <typename AlgorithmT> class RoutingAlgorithms final : public RoutingAlg
     }
 
     InternalRouteResult
-    AlternativeRouting(const PhantomNodes &phantom_node_pair) const final override
+    AlternativePathSearch(const PhantomNodes &phantom_node_pair) const final override
     {
         return routing_algorithms::alternativePathSearch(heaps, facade, phantom_node_pair);
     }
 
     InternalRouteResult
-    ShortestRouting(const std::vector<PhantomNodes> &phantom_node_pair,
+    ShortestPathSearch(const std::vector<PhantomNodes> &phantom_node_pair,
                     const boost::optional<bool> continue_straight_at_waypoint) const final override
     {
         return routing_algorithms::shortestPathSearch(
             heaps, facade, phantom_node_pair, continue_straight_at_waypoint);
     }
 
-    InternalRouteResult DirectShortestPathRouting(
+    InternalRouteResult DirectShortestPathSearch(
         const std::vector<PhantomNodes> &phantom_node_pair) const final override
     {
         return routing_algorithms::directShortestPathSearch(heaps, facade, phantom_node_pair);
     }
 
     std::vector<EdgeWeight>
-    ManyToManyRouting(const std::vector<PhantomNode> &phantom_nodes,
+    ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
                       const std::vector<std::size_t> &source_indices,
                       const std::vector<std::size_t> &target_indices) const final override
     {
@@ -100,15 +112,40 @@ template <typename AlgorithmT> class RoutingAlgorithms final : public RoutingAlg
     }
 
     std::vector<routing_algorithms::TurnData>
-    TileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
+    GetTileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
               const std::vector<std::size_t> &sorted_edge_indexes) const final override
     {
         return routing_algorithms::getTileTurns(facade, edges, sorted_edge_indexes);
     }
 
-    bool HasAlternativeRouting() const final override
+    bool HasAlternativePathSearch() const final override
     {
-        return algorithm_trais::HasAlternativeRouting<AlgorithmT>()(facade);
+        return algorithm_trais::HasAlternativePathSearch<AlgorithmT>::value;
+    }
+
+    bool HasShortestPathSearch() const final override
+    {
+        return algorithm_trais::HasShortestPathSearch<AlgorithmT>::value;
+    }
+
+    bool HasDirectShortestPathSearch() const final override
+    {
+        return algorithm_trais::HasDirectShortestPathSearch<AlgorithmT>::value;
+    }
+
+    bool HasMapMatching() const final override
+    {
+        return algorithm_trais::HasMapMatching<AlgorithmT>::value;
+    }
+
+    bool HasManyToManySearch() const final override
+    {
+        return algorithm_trais::HasManyToManySearch<AlgorithmT>::value;
+    }
+
+    bool HasGetTileTurns() const final override
+    {
+        return algorithm_trais::HasGetTileTurns<AlgorithmT>::value;
     }
 
   private:

include/engine/routing_algorithms/alternative_path.hpp

@@ -7,6 +7,8 @@
 #include "engine/algorithm.hpp"
 #include "engine/search_engine_data.hpp"
 
+#include "util/exception.hpp"
+
 namespace osrm
 {
 namespace engine
@@ -14,6 +16,16 @@ namespace engine
 namespace routing_algorithms
 {
 
+template <typename AlgorithmT>
+InternalRouteResult
+alternativePathSearch(SearchEngineData &,
+                      const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
+                      const PhantomNodes &)
+{
+    throw util::exception(std::string("alternativePathSearch is not implemented for ") +
+                          typeid(AlgorithmT).name());
+}
+
 InternalRouteResult
 alternativePathSearch(SearchEngineData &search_engine_data,
                       const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,

include/engine/routing_algorithms/direct_shortest_path.hpp

@@ -15,6 +15,16 @@ namespace engine
 namespace routing_algorithms
 {
 
+template <typename AlgorithmT>
+InternalRouteResult
+directShortestPathSearch(SearchEngineData &,
+                         const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
+                         const std::vector<PhantomNodes> &)
+{
+    throw util::exception(std::string("directShortestPathSearch is not implemented for ") +
+                          typeid(AlgorithmT).name());
+}
+
 /// This is a striped down version of the general shortest path algorithm.
 /// The general algorithm always computes two queries for each leg. This is only
 /// necessary in case of vias, where the directions of the start node is constrainted

include/engine/routing_algorithms/many_to_many.hpp

@@ -17,6 +17,18 @@ namespace engine
 namespace routing_algorithms
 {
 
+template <typename AlgorithmT>
+std::vector<EdgeWeight>
+manyToManySearch(SearchEngineData &,
+                 const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
+                 const std::vector<PhantomNode> &,
+                 const std::vector<std::size_t> &,
+                 const std::vector<std::size_t> &)
+{
+    throw util::exception(std::string("manyToManySearch is not implemented for ") +
+                          typeid(AlgorithmT).name());
+}
+
 std::vector<EdgeWeight>
 manyToManySearch(SearchEngineData &engine_working_data,
                  const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,

include/engine/routing_algorithms/map_matching.hpp

@@ -20,6 +20,18 @@ using CandidateLists = std::vector<CandidateList>;
 using SubMatchingList = std::vector<map_matching::SubMatching>;
 static const constexpr double DEFAULT_GPS_PRECISION = 5;
 
+template <typename AlgorithmT>
+SubMatchingList mapMatching(SearchEngineData &,
+                            const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
+                            const CandidateLists &,
+                            const std::vector<util::Coordinate> &,
+                            const std::vector<unsigned> &,
+                            const std::vector<boost::optional<double>> &)
+{
+    throw util::exception(std::string("mapMatching is not implemented for ") +
+                          typeid(AlgorithmT).name());
+}
+
 SubMatchingList
 mapMatching(SearchEngineData &engine_working_data,
             const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,

include/engine/routing_algorithms/shortest_path.hpp

@@ -13,6 +13,17 @@ namespace engine
 namespace routing_algorithms
 {
 
+template <typename AlgorithmT>
+InternalRouteResult
+shortestPathSearch(SearchEngineData &,
+                   const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
+                   const std::vector<PhantomNodes> &,
+                   const boost::optional<bool>)
+{
+    throw util::exception(std::string("shortestPathSearch is not implemented for ") +
+                          typeid(AlgorithmT).name());
+}
+
 InternalRouteResult
 shortestPathSearch(SearchEngineData &engine_working_data,
                    const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,

include/engine/routing_algorithms/tile_turns.hpp

@@ -27,6 +27,16 @@ struct TurnData final
 
 using RTreeLeaf = datafacade::BaseDataFacade::RTreeLeaf;
 
+template <typename AlgorithmT>
+std::vector<TurnData>
+getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
+             const std::vector<RTreeLeaf> &,
+             const std::vector<std::size_t> &)
+{
+    throw util::exception(std::string("getTileTurns is not implemented for ") +
+                          typeid(AlgorithmT).name());
+}
+
 std::vector<TurnData>
 getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
              const std::vector<RTreeLeaf> &edges,

src/engine/plugins/match.cpp

@@ -113,6 +113,11 @@ Status MatchPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
                                   const api::MatchParameters &parameters,
                                   util::json::Object &json_result) const
 {
+    if (!algorithms.HasMapMatching())
+    {
+        return Error("NotImplemented", "Map matching is not implemented for the chosen search algorithm.", json_result);
+    }
+
     BOOST_ASSERT(parameters.IsValid());
 
     // enforce maximum number of locations for performance reasons
@@ -209,7 +214,7 @@ Status MatchPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
         // bi-directional
         // phantom nodes for possible uturns
         sub_routes[index] =
-            algorithms.ShortestRouting(sub_routes[index].segment_end_coordinates, {false});
+            algorithms.ShortestPathSearch(sub_routes[index].segment_end_coordinates, {false});
         BOOST_ASSERT(sub_routes[index].shortest_path_length != INVALID_EDGE_WEIGHT);
     }
 

src/engine/plugins/table.cpp

@@ -33,6 +33,11 @@ Status TablePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
                                   const api::TableParameters &params,
                                   util::json::Object &result) const
 {
+    if (!algorithms.HasManyToManySearch())
+    {
+        return Error("NotImplemented", "Many to many search is not implemented for the chosen search algorithm.", result);
+    }
+
     BOOST_ASSERT(params.IsValid());
 
     if (!CheckAllCoordinates(params.coordinates))
@@ -62,7 +67,7 @@ Status TablePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
 
     auto snapped_phantoms = SnapPhantomNodes(GetPhantomNodes(facade, params));
     auto result_table =
-        algorithms.ManyToManyRouting(snapped_phantoms, params.sources, params.destinations);
+        algorithms.ManyToManySearch(snapped_phantoms, params.sources, params.destinations);
 
     if (result_table.empty())
     {

src/engine/plugins/tile.cpp

@@ -756,9 +756,9 @@ Status TilePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataF
 
     // If we're zooming into 16 or higher, include turn data.  Why?  Because turns make the map
     // really cramped, so we don't bother including the data for tiles that span a large area.
-    if (parameters.z >= MIN_ZOOM_FOR_TURNS)
+    if (parameters.z >= MIN_ZOOM_FOR_TURNS && algorithms.HasGetTileTurns())
     {
-        turns = algorithms.TileTurns(edges, edge_index);
+        turns = algorithms.GetTileTurns(edges, edge_index);
     }
 
     encodeVectorTile(

src/engine/plugins/trip.cpp

@@ -85,7 +85,7 @@ InternalRouteResult TripPlugin::ComputeRoute(const RoutingAlgorithmsInterface &a
         BOOST_ASSERT(min_route.segment_end_coordinates.size() == trip.size() - 1);
     }
 
-    min_route = algorithms.ShortestRouting(min_route.segment_end_coordinates, {false});
+    min_route = algorithms.ShortestPathSearch(min_route.segment_end_coordinates, {false});
     BOOST_ASSERT_MSG(min_route.shortest_path_length < INVALID_EDGE_WEIGHT, "unroutable route");
     return min_route;
 }
@@ -147,6 +147,15 @@ Status TripPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataF
                                  const api::TripParameters &parameters,
                                  util::json::Object &json_result) const
 {
+    if (!algorithms.HasShortestPathSearch())
+    {
+        return Error("NotImplemented", "Shortest path search is not implemented for the chosen search algorithm.", json_result);
+    }
+    if (!algorithms.HasManyToManySearch())
+    {
+        return Error("NotImplemented", "Many to many search is not implemented for the chosen search algorithm.", json_result);
+    }
+
     BOOST_ASSERT(parameters.IsValid());
     const auto number_of_locations = parameters.coordinates.size();
 
@@ -201,7 +210,7 @@ Status TripPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataF
 
     // compute the duration table of all phantom nodes
     auto result_table = util::DistTableWrapper<EdgeWeight>(
-        algorithms.ManyToManyRouting(snapped_phantoms, {}, {}), number_of_locations);
+        algorithms.ManyToManySearch(snapped_phantoms, {}, {}), number_of_locations);
 
     if (result_table.size() == 0)
     {

src/engine/plugins/viaroute.cpp

@@ -34,6 +34,16 @@ ViaRoutePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFaca
 {
     BOOST_ASSERT(route_parameters.IsValid());
 
+    if (!algorithms.HasShortestPathSearch() && route_parameters.coordinates.size() > 2)
+    {
+        return Error("NotImplemented", "Shortest path search is not implemented for the chosen search algorithm. Only two coordinates supported.", json_result);
+    }
+
+    if (!algorithms.HasDirectShortestPathSearch() && !algorithms.HasShortestPathSearch())
+    {
+        return Error("NotImplemented", "Direct shortest path search is not implemented for the chosen search algorithm.", json_result);
+    }
+
     if (max_locations_viaroute > 0 &&
         (static_cast<int>(route_parameters.coordinates.size()) > max_locations_viaroute))
     {
@@ -85,20 +95,17 @@ ViaRoutePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFaca
     };
     util::for_each_pair(snapped_phantoms, build_phantom_pairs);
 
-    if (1 == raw_route.segment_end_coordinates.size())
+    if (1 == raw_route.segment_end_coordinates.size() && algorithms.HasAlternativePathSearch() && route_parameters.alternatives)
     {
-        if (route_parameters.alternatives && algorithms.HasAlternativeRouting())
+        raw_route = algorithms.AlternativePathSearch(raw_route.segment_end_coordinates.front());
-        {
+    }
-            raw_route = algorithms.AlternativeRouting(raw_route.segment_end_coordinates.front());
+    else if (1 == raw_route.segment_end_coordinates.size() && algorithms.HasDirectShortestPathSearch())
-        }
+    {
-        else
+        raw_route = algorithms.DirectShortestPathSearch(raw_route.segment_end_coordinates);
-        {
-            raw_route = algorithms.DirectShortestPathRouting(raw_route.segment_end_coordinates);
-        }
     }
     else
     {
-        raw_route = algorithms.ShortestRouting(raw_route.segment_end_coordinates,
+        raw_route = algorithms.ShortestPathSearch(raw_route.segment_end_coordinates,
                                                route_parameters.continue_straight);
     }