Addressed PR comments by @daniel-j-h and @oxidase

include/engine/routing_algorithms/alternative_path.hpp

@@ -16,16 +16,6 @@ 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,16 +15,6 @@ 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,18 +17,6 @@ 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

@@ -15,23 +15,14 @@ namespace engine
 namespace routing_algorithms
 {
 
+
 using CandidateList = std::vector<PhantomNodeWithDistance>;
 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());
-}
-
+//[1] "Hidden Markov Map Matching Through Noise and Sparseness";
+//     P. Newson and J. Krumm; 2009; ACM GIS
 SubMatchingList
 mapMatching(SearchEngineData &engine_working_data,
             const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
@@ -51,7 +42,4 @@ mapMatching(SearchEngineData &engine_working_data,
 }
 }
 
-//[1] "Hidden Markov Map Matching Through Noise and Sparseness"; P. Newson and J. Krumm; 2009; ACM
-// GIS
-
 #endif /* MAP_MATCHING_HPP */

include/engine/routing_algorithms/routing_base.hpp

@@ -41,7 +41,7 @@ template <bool DIRECTION, typename HeapT>
 bool stallAtNode(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
                  const NodeID node,
                  const EdgeWeight weight,
-                 HeapT &query_heap)
+                 const HeapT &query_heap)
 {
     for (auto edge : facade.GetAdjacentEdgeRange(node))
     {

include/engine/routing_algorithms/shortest_path.hpp

@@ -13,17 +13,6 @@ 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,16 +27,6 @@ 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,