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

include/engine/algorithm.hpp

@@ -18,6 +18,10 @@ struct CH final
 struct CoreCH final
 {
 };
+
+template<typename AlgorithmT> const char* name();
+template<> inline const char* name<CH>() { return "CH"; }
+template<> inline const char* name<CoreCH>() { return "CoreCH"; }
 }
 
 namespace algorithm_trais

include/engine/data_watchdog.hpp

@@ -44,7 +44,7 @@ template <typename AlgorithmT> class DataWatchdog final
         watcher = std::thread(&DataWatchdog::Run, this);
     }
 
-    virtual ~DataWatchdog()
+    ~DataWatchdog()
     {
         active = false;
         barrier.notify_all();

include/engine/engine.hpp

@@ -35,7 +35,7 @@ namespace engine
 class EngineInterface
 {
   public:
-    virtual ~EngineInterface(){};
+    virtual ~EngineInterface() = default;
     virtual Status Route(const api::RouteParameters &parameters,
                          util::json::Object &result) const = 0;
     virtual Status Table(const api::TableParameters &parameters,
@@ -63,10 +63,12 @@ template <typename AlgorithmT> class Engine final : public EngineInterface
     {
         if (config.use_shared_memory)
         {
+            util::Log(logDEBUG) << "Using shared memory with algorithm " << algorithm::name<AlgorithmT>();
             facade_provider = std::make_unique<WatchingProvider<AlgorithmT>>();
         }
         else
         {
+            util::Log(logDEBUG) << "Using internal memory with algorithm " << algorithm::name<AlgorithmT>();
             facade_provider =
                 std::make_unique<ImmutableProvider<AlgorithmT>>(config.storage_config);
         }
@@ -77,7 +79,7 @@ template <typename AlgorithmT> class Engine final : public EngineInterface
 
     Engine(const Engine &) = delete;
     Engine &operator=(const Engine &) = delete;
-    virtual ~Engine(){};
+    virtual ~Engine() = default;
 
     Status Route(const api::RouteParameters &params,
                  util::json::Object &result) const override final
@@ -155,6 +157,8 @@ template <> bool Engine<algorithm::CH>::CheckCompability(const EngineConfig &con
     else
     {
         std::ifstream in(config.storage_config.hsgr_data_path.string().c_str());
+        if (!in) return false;
+
         in.seekg(0, std::ios::end);
         auto size = in.tellg();
         return size > 0;
@@ -176,12 +180,13 @@ template <> bool Engine<algorithm::CoreCH>::CheckCompability(const EngineConfig
 
         auto mem = storage::makeSharedMemory(barrier.data().region);
         auto layout = reinterpret_cast<storage::DataLayout *>(mem->Ptr());
-        std::cout << layout->GetBlockSize(storage::DataLayout::CH_CORE_MARKER) << std::endl;
         return layout->GetBlockSize(storage::DataLayout::CH_CORE_MARKER) > 4;
     }
     else
     {
         std::ifstream in(config.storage_config.core_data_path.string().c_str());
+        if (!in) return false;
+
         in.seekg(0, std::ios::end);
         std::size_t size = in.tellg();
         // An empty core files is only the 4 byte size header.

include/engine/routing_algorithms.hpp

@@ -52,14 +52,6 @@ class RoutingAlgorithmsInterface
     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
 {

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>
+//[1] "Hidden Markov Map Matching Through Noise and Sparseness";
-SubMatchingList mapMatching(SearchEngineData &,
+//     P. Newson and J. Krumm; 2009; ACM GIS
-                            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,
@@ -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,

include/util/binary_heap.hpp

@@ -145,6 +145,12 @@ class BinaryHeap
         return inserted_nodes[index].weight;
     }
 
+    const Weight &GetKey(NodeID node) const
+    {
+        const Key index = node_index.peek_index(node);
+        return inserted_nodes[index].weight;
+    }
+
     bool WasRemoved(const NodeID node) const
     {
         BOOST_ASSERT(WasInserted(node));

src/engine/plugins/tile.cpp

@@ -259,7 +259,7 @@ std::vector<std::size_t> getEdgeIndex(const std::vector<RTreeLeaf> &edges)
     // GetEdgesInBox is marked `const`, so we can't sort the array itself,
     // instead we create an array of indexes and sort that instead.
     std::vector<std::size_t> sorted_edge_indexes(edges.size(), 0);
-    std::iota(sorted_edge_indexes.begin(), sorted_edge_indexes.end(), 0); // fill with 1,2,3,...N
+    std::iota(sorted_edge_indexes.begin(), sorted_edge_indexes.end(), 0); // fill with 0,1,2,3,...N-1
 
     // Now, sort that array based on the edges list, using the u/v node IDs
     // as the sort condition