Add type traits to disable plugins for specific algorithms

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,