itroduce ADL via algorithm specific ch, corech and mld namespaces

include/engine/algorithm.hpp

@@ -7,30 +7,36 @@ namespace osrm
 {
 namespace engine
 {
-namespace algorithm
+namespace routing_algorithms
 {
 
 // Contraction Hiearchy
-struct CH final
+namespace ch
+{
+struct Algorithm final
 {
 };
+}
 // Contraction Hiearchy with core
-struct CoreCH final
+namespace corech
+{
+struct Algorithm final
 {
 };
+}
 // Multi-Level Dijkstra
-struct MLD final
+namespace mld
+{
+struct Algorithm final
 {
 };
-
-template <typename AlgorithmT> const char *name();
-template <> inline const char *name<CH>() { return "CH"; }
-template <> inline const char *name<CoreCH>() { return "CoreCH"; }
-template <> inline const char *name<MLD>() { return "MLD"; }
 }
 
-namespace algorithm_trais
-{
+// Algorithm names
+template <typename AlgorithmT> const char *name();
+template <> inline const char *name<ch::Algorithm>() { return "CH"; }
+template <> inline const char *name<corech::Algorithm>() { return "CoreCH"; }
+template <> inline const char *name<mld::Algorithm>() { return "MLD"; }
 
 template <typename AlgorithmT> struct HasAlternativePathSearch final : std::false_type
 {
@@ -51,62 +57,64 @@ template <typename AlgorithmT> struct HasGetTileTurns final : std::false_type
 {
 };
 
-template <> struct HasAlternativePathSearch<algorithm::CH> final : std::true_type
+// Algorithms supported by Contraction Hierarchies
+template <> struct HasAlternativePathSearch<ch::Algorithm> final : std::true_type
 {
 };
-template <> struct HasShortestPathSearch<algorithm::CH> final : std::true_type
+template <> struct HasShortestPathSearch<ch::Algorithm> final : std::true_type
 {
 };
-template <> struct HasDirectShortestPathSearch<algorithm::CH> final : std::true_type
+template <> struct HasDirectShortestPathSearch<ch::Algorithm> final : std::true_type
 {
 };
-template <> struct HasMapMatching<algorithm::CH> final : std::true_type
+template <> struct HasMapMatching<ch::Algorithm> final : std::true_type
 {
 };
-template <> struct HasManyToManySearch<algorithm::CH> final : std::true_type
+template <> struct HasManyToManySearch<ch::Algorithm> final : std::true_type
 {
 };
-template <> struct HasGetTileTurns<algorithm::CH> final : std::true_type
+template <> struct HasGetTileTurns<ch::Algorithm> final : std::true_type
 {
 };
 
+// Algorithms supported by Contraction Hierarchies with core
+template <> struct HasShortestPathSearch<corech::Algorithm> final : std::true_type
+{
+};
+template <> struct HasDirectShortestPathSearch<corech::Algorithm> final : std::true_type
+{
+};
+template <> struct HasMapMatching<corech::Algorithm> final : std::true_type
+{
+};
+template <> struct HasGetTileTurns<corech::Algorithm> final : std::true_type
+{
+};
 // disbaled because of perfomance reasons
-template <> struct HasAlternativePathSearch<algorithm::CoreCH> final : std::false_type
+template <> struct HasAlternativePathSearch<corech::Algorithm> final : std::false_type
 {
 };
-template <> struct HasManyToManySearch<algorithm::CoreCH> final : std::false_type
-{
-};
-template <> struct HasShortestPathSearch<algorithm::CoreCH> final : std::true_type
-{
-};
-template <> struct HasDirectShortestPathSearch<algorithm::CoreCH> final : std::true_type
-{
-};
-template <> struct HasMapMatching<algorithm::CoreCH> final : std::true_type
-{
-};
-template <> struct HasGetTileTurns<algorithm::CoreCH> final : std::true_type
+template <> struct HasManyToManySearch<corech::Algorithm> final : std::false_type
 {
 };
 
-// disbaled because of perfomance reasons
-template <> struct HasAlternativePathSearch<algorithm::MLD> final : std::false_type
+// Algorithms supported by Multi-Level Dijkstra
+template <> struct HasDirectShortestPathSearch<mld::Algorithm> final : std::true_type
 {
 };
-template <> struct HasManyToManySearch<algorithm::MLD> final : std::false_type
+template <> struct HasMapMatching<mld::Algorithm> final : std::false_type
 {
 };
-template <> struct HasShortestPathSearch<algorithm::MLD> final : std::false_type
+template <> struct HasAlternativePathSearch<mld::Algorithm> final : std::false_type
 {
 };
-template <> struct HasDirectShortestPathSearch<algorithm::MLD> final : std::true_type
+template <> struct HasManyToManySearch<mld::Algorithm> final : std::false_type
 {
 };
-template <> struct HasMapMatching<algorithm::MLD> final : std::false_type
+template <> struct HasShortestPathSearch<mld::Algorithm> final : std::false_type
 {
 };
-template <> struct HasGetTileTurns<algorithm::MLD> final : std::false_type
+template <> struct HasGetTileTurns<mld::Algorithm> final : std::false_type
 {
 };
 }

include/engine/datafacade/algorithm_datafacade.hpp

@@ -17,11 +17,16 @@ namespace engine
 namespace datafacade
 {
 
+// Namespace local aliases for algorithms
+using CH = routing_algorithms::ch::Algorithm;
+using CoreCH = routing_algorithms::corech::Algorithm;
+using MLD = routing_algorithms::mld::Algorithm;
+
 using EdgeRange = util::range<EdgeID>;
 
 template <typename AlgorithmT> class AlgorithmDataFacade;
 
-template <> class AlgorithmDataFacade<algorithm::CH>
+template <> class AlgorithmDataFacade<CH>
 {
   public:
     using EdgeData = contractor::QueryEdge::EdgeData;
@@ -56,7 +61,7 @@ template <> class AlgorithmDataFacade<algorithm::CH>
                                     const std::function<bool(EdgeData)> filter) const = 0;
 };
 
-template <> class AlgorithmDataFacade<algorithm::CoreCH>
+template <> class AlgorithmDataFacade<CoreCH>
 {
   public:
     using EdgeData = contractor::QueryEdge::EdgeData;
@@ -64,7 +69,7 @@ template <> class AlgorithmDataFacade<algorithm::CoreCH>
     virtual bool IsCoreNode(const NodeID id) const = 0;
 };
 
-template <> class AlgorithmDataFacade<algorithm::MLD>
+template <> class AlgorithmDataFacade<MLD>
 {
   public:
     using EdgeData = extractor::EdgeBasedEdge::EdgeData;

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -58,8 +58,7 @@ namespace datafacade
 template <typename AlgorithmT> class ContiguousInternalMemoryAlgorithmDataFacade;
 
 template <>
-class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>
-    : public datafacade::AlgorithmDataFacade<algorithm::CH>
+class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::AlgorithmDataFacade<CH>
 {
   private:
     using QueryGraph = util::StaticGraph<EdgeData, storage::Ownership::View>;
@@ -151,8 +150,8 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>
 };
 
 template <>
-class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CoreCH>
-    : public datafacade::AlgorithmDataFacade<algorithm::CoreCH>
+class ContiguousInternalMemoryAlgorithmDataFacade<CoreCH>
+    : public datafacade::AlgorithmDataFacade<CoreCH>
 {
   private:
     util::vector_view<bool> m_is_core_node;
@@ -869,36 +868,34 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 template <typename AlgorithmT> class ContiguousInternalMemoryDataFacade;
 
 template <>
-class ContiguousInternalMemoryDataFacade<algorithm::CH>
+class ContiguousInternalMemoryDataFacade<CH>
     : public ContiguousInternalMemoryDataFacadeBase,
-      public ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>
+      public ContiguousInternalMemoryAlgorithmDataFacade<CH>
 {
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator)
         : ContiguousInternalMemoryDataFacadeBase(allocator),
-          ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>(allocator)
+          ContiguousInternalMemoryAlgorithmDataFacade<CH>(allocator)
 
     {
     }
 };
 
 template <>
-class ContiguousInternalMemoryDataFacade<algorithm::CoreCH> final
-    : public ContiguousInternalMemoryDataFacade<algorithm::CH>,
-      public ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CoreCH>
+class ContiguousInternalMemoryDataFacade<CoreCH> final
+    : public ContiguousInternalMemoryDataFacade<CH>,
+      public ContiguousInternalMemoryAlgorithmDataFacade<CoreCH>
 {
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator)
-        : ContiguousInternalMemoryDataFacade<algorithm::CH>(allocator),
-          ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CoreCH>(allocator)
+        : ContiguousInternalMemoryDataFacade<CH>(allocator),
+          ContiguousInternalMemoryAlgorithmDataFacade<CoreCH>(allocator)
 
     {
     }
 };
 
-template <>
-class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
-    : public datafacade::AlgorithmDataFacade<algorithm::MLD>
+template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public AlgorithmDataFacade<MLD>
 {
     // MLD data
     partition::MultiLevelPartitionView mld_partition;
@@ -1065,15 +1062,15 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
 };
 
 template <>
-class ContiguousInternalMemoryDataFacade<algorithm::MLD> final
+class ContiguousInternalMemoryDataFacade<MLD> final
     : public ContiguousInternalMemoryDataFacadeBase,
-      public ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
+      public ContiguousInternalMemoryAlgorithmDataFacade<MLD>
 {
   private:
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator)
         : ContiguousInternalMemoryDataFacadeBase(allocator),
-          ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>(allocator)
+          ContiguousInternalMemoryAlgorithmDataFacade<MLD>(allocator)
 
     {
     }

include/engine/engine.hpp

@@ -64,13 +64,13 @@ template <typename AlgorithmT> class Engine final : public EngineInterface
         if (config.use_shared_memory)
         {
             util::Log(logDEBUG) << "Using shared memory with algorithm "
-                                << algorithm::name<AlgorithmT>();
+                                << routing_algorithms::name<AlgorithmT>();
             facade_provider = std::make_unique<WatchingProvider<AlgorithmT>>();
         }
         else
         {
             util::Log(logDEBUG) << "Using internal memory with algorithm "
-                                << algorithm::name<AlgorithmT>();
+                                << routing_algorithms::name<AlgorithmT>();
             facade_provider =
                 std::make_unique<ImmutableProvider<AlgorithmT>>(config.storage_config);
         }
@@ -143,7 +143,8 @@ template <typename AlgorithmT> class Engine final : public EngineInterface
     const plugins::TilePlugin tile_plugin;
 };
 
-template <> bool Engine<algorithm::CH>::CheckCompability(const EngineConfig &config)
+template <>
+bool Engine<routing_algorithms::ch::Algorithm>::CheckCompability(const EngineConfig &config)
 {
     if (config.use_shared_memory)
     {
@@ -168,9 +169,10 @@ template <> bool Engine<algorithm::CH>::CheckCompability(const EngineConfig &con
     }
 }
 
-template <> bool Engine<algorithm::CoreCH>::CheckCompability(const EngineConfig &config)
+template <>
+bool Engine<routing_algorithms::corech::Algorithm>::CheckCompability(const EngineConfig &config)
 {
-    if (!Engine<algorithm::CH>::CheckCompability(config))
+    if (!Engine<routing_algorithms::ch::Algorithm>::CheckCompability(config))
     {
         return false;
     }

include/engine/routing_algorithms.hpp

@@ -93,32 +93,32 @@ template <typename AlgorithmT> class RoutingAlgorithms final : public RoutingAlg
 
     bool HasAlternativePathSearch() const final override
     {
-        return algorithm_trais::HasAlternativePathSearch<AlgorithmT>::value;
+        return routing_algorithms::HasAlternativePathSearch<AlgorithmT>::value;
     }
 
     bool HasShortestPathSearch() const final override
     {
-        return algorithm_trais::HasShortestPathSearch<AlgorithmT>::value;
+        return routing_algorithms::HasShortestPathSearch<AlgorithmT>::value;
     }
 
     bool HasDirectShortestPathSearch() const final override
     {
-        return algorithm_trais::HasDirectShortestPathSearch<AlgorithmT>::value;
+        return routing_algorithms::HasDirectShortestPathSearch<AlgorithmT>::value;
     }
 
     bool HasMapMatching() const final override
     {
-        return algorithm_trais::HasMapMatching<AlgorithmT>::value;
+        return routing_algorithms::HasMapMatching<AlgorithmT>::value;
     }
 
     bool HasManyToManySearch() const final override
     {
-        return algorithm_trais::HasManyToManySearch<AlgorithmT>::value;
+        return routing_algorithms::HasManyToManySearch<AlgorithmT>::value;
     }
 
     bool HasGetTileTurns() const final override
     {
-        return algorithm_trais::HasGetTileTurns<AlgorithmT>::value;
+        return routing_algorithms::HasGetTileTurns<AlgorithmT>::value;
     }
 
   private:
@@ -131,7 +131,7 @@ template <typename AlgorithmT>
 InternalRouteResult
 RoutingAlgorithms<AlgorithmT>::AlternativePathSearch(const PhantomNodes &phantom_node_pair) const
 {
-    return routing_algorithms::alternativePathSearch(heaps, facade, phantom_node_pair);
+    return routing_algorithms::ch::alternativePathSearch(heaps, facade, phantom_node_pair);
 }
 
 template <typename AlgorithmT>
@@ -156,7 +156,7 @@ std::vector<EdgeWeight> RoutingAlgorithms<AlgorithmT>::ManyToManySearch(
     const std::vector<std::size_t> &source_indices,
     const std::vector<std::size_t> &target_indices) const
 {
-    return routing_algorithms::manyToManySearch(
+    return routing_algorithms::ch::manyToManySearch(
         heaps, facade, phantom_nodes, source_indices, target_indices);
 }
 
@@ -168,13 +168,13 @@ inline routing_algorithms::SubMatchingList RoutingAlgorithms<AlgorithmT>::MapMat
     const std::vector<boost::optional<double>> &trace_gps_precision,
     const bool allow_splitting) const
 {
-    return routing_algorithms::mapMatching(heaps,
-                                           facade,
-                                           candidates_list,
-                                           trace_coordinates,
-                                           trace_timestamps,
-                                           trace_gps_precision,
-                                           allow_splitting);
+    return routing_algorithms::ch::mapMatching(heaps,
+                                               facade,
+                                               candidates_list,
+                                               trace_coordinates,
+                                               trace_timestamps,
+                                               trace_gps_precision,
+                                               allow_splitting);
 }
 
 template <typename AlgorithmT>
@@ -187,42 +187,45 @@ inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<AlgorithmT>::
 
 // MLD overrides for not implemented
 template <>
-InternalRouteResult inline RoutingAlgorithms<algorithm::MLD>::AlternativePathSearch(
-    const PhantomNodes &) const
+InternalRouteResult inline RoutingAlgorithms<
+    routing_algorithms::mld::Algorithm>::AlternativePathSearch(const PhantomNodes &) const
 {
     throw util::exception("AlternativePathSearch is not implemented");
 }
 
 template <>
 inline InternalRouteResult
-RoutingAlgorithms<algorithm::MLD>::ShortestPathSearch(const std::vector<PhantomNodes> &,
-                                                      const boost::optional<bool>) const
+RoutingAlgorithms<routing_algorithms::mld::Algorithm>::ShortestPathSearch(
+    const std::vector<PhantomNodes> &, const boost::optional<bool>) const
 {
     throw util::exception("ShortestPathSearch is not implemented");
 }
 
 template <>
 inline std::vector<EdgeWeight>
-RoutingAlgorithms<algorithm::MLD>::ManyToManySearch(const std::vector<PhantomNode> &,
-                                                    const std::vector<std::size_t> &,
-                                                    const std::vector<std::size_t> &) const
+RoutingAlgorithms<routing_algorithms::mld::Algorithm>::ManyToManySearch(
+    const std::vector<PhantomNode> &,
+    const std::vector<std::size_t> &,
+    const std::vector<std::size_t> &) const
 {
     throw util::exception("ManyToManySearch is not implemented");
 }
 
 template <>
 inline routing_algorithms::SubMatchingList
-RoutingAlgorithms<algorithm::MLD>::MapMatching(const routing_algorithms::CandidateLists &,
-                                               const std::vector<util::Coordinate> &,
-                                               const std::vector<unsigned> &,
-                                               const std::vector<boost::optional<double>> &,
-                                               const bool) const
+RoutingAlgorithms<routing_algorithms::mld::Algorithm>::MapMatching(
+    const routing_algorithms::CandidateLists &,
+    const std::vector<util::Coordinate> &,
+    const std::vector<unsigned> &,
+    const std::vector<boost::optional<double>> &,
+    const bool) const
 {
     throw util::exception("MapMatching is not implemented");
 }
 
 template <>
-inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<algorithm::MLD>::GetTileTurns(
+inline std::vector<routing_algorithms::TurnData>
+RoutingAlgorithms<routing_algorithms::mld::Algorithm>::GetTileTurns(
     const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &,
     const std::vector<std::size_t> &) const
 {

include/engine/routing_algorithms/alternative_path.hpp

@@ -15,12 +15,13 @@ namespace engine
 {
 namespace routing_algorithms
 {
-
+namespace ch
+{
 InternalRouteResult
 alternativePathSearch(SearchEngineData &search_engine_data,
-                      const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                      const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
                       const PhantomNodes &phantom_node_pair);
-
+} // namespace ch
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm

include/engine/routing_algorithms/many_to_many.hpp

@@ -13,16 +13,18 @@ namespace osrm
 {
 namespace engine
 {
-
 namespace routing_algorithms
 {
 
+namespace ch
+{
 std::vector<EdgeWeight>
 manyToManySearch(SearchEngineData &engine_working_data,
-                 const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                 const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                  const std::vector<PhantomNode> &phantom_nodes,
                  const std::vector<std::size_t> &source_indices,
                  const std::vector<std::size_t> &target_indices);
+} // namespace ch
 
 } // namespace routing_algorithms
 } // namespace engine

include/engine/routing_algorithms/map_matching.hpp

@@ -22,23 +22,27 @@ static const constexpr double DEFAULT_GPS_PRECISION = 5;
 
 //[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,
-            const CandidateLists &candidates_list,
-            const std::vector<util::Coordinate> &trace_coordinates,
-            const std::vector<unsigned> &trace_timestamps,
-            const std::vector<boost::optional<double>> &trace_gps_precision,
-            const bool allow_splitting);
+namespace ch
+{
+SubMatchingList mapMatching(SearchEngineData &engine_working_data,
+                            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                            const CandidateLists &candidates_list,
+                            const std::vector<util::Coordinate> &trace_coordinates,
+                            const std::vector<unsigned> &trace_timestamps,
+                            const std::vector<boost::optional<double>> &trace_gps_precision,
+                            const bool allow_splitting);
+}
 
-SubMatchingList
-mapMatching(SearchEngineData &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
-            const CandidateLists &candidates_list,
-            const std::vector<util::Coordinate> &trace_coordinates,
-            const std::vector<unsigned> &trace_timestamps,
-            const std::vector<boost::optional<double>> &trace_gps_precision,
-            const bool allow_splitting);
+namespace corech
+{
+SubMatchingList mapMatching(SearchEngineData &engine_working_data,
+                            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                            const CandidateLists &candidates_list,
+                            const std::vector<util::Coordinate> &trace_coordinates,
+                            const std::vector<unsigned> &trace_timestamps,
+                            const std::vector<boost::optional<double>> &trace_gps_precision,
+                            const bool allow_splitting);
+}
 }
 }
 }

include/engine/routing_algorithms/routing_base_ch.hpp

@@ -23,7 +23,7 @@ namespace ch
 
 // Stalling
 template <bool DIRECTION, typename HeapT>
-bool stallAtNode(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+bool stallAtNode(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                  const NodeID node,
                  const EdgeWeight weight,
                  const HeapT &query_heap)
@@ -49,7 +49,7 @@ bool stallAtNode(const datafacade::ContiguousInternalMemoryDataFacade<algorithm:
 }
 
 template <bool DIRECTION>
-void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         SearchEngineData::QueryHeap &heap)
@@ -113,7 +113,7 @@ we need to add an offset to the termination criterion.
 static constexpr bool ENABLE_STALLING = true;
 static constexpr bool DISABLE_STALLING = false;
 template <bool DIRECTION, bool STALLING = ENABLE_STALLING>
-void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                  SearchEngineData::QueryHeap &forward_heap,
                  SearchEngineData::QueryHeap &reverse_heap,
                  NodeID &middle_node_id,
@@ -186,9 +186,8 @@ void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<algorithm:
 }
 
 template <bool UseDuration>
-EdgeWeight
-getLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
-              NodeID node)
+EdgeWeight getLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                         NodeID node)
 {
     EdgeWeight loop_weight = UseDuration ? MAXIMAL_EDGE_DURATION : INVALID_EDGE_WEIGHT;
     for (auto edge : facade.GetAdjacentEdgeRange(node))
@@ -228,7 +227,7 @@ getLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH
  * original edge found.
  */
 template <typename BidirectionalIterator, typename Callback>
-void unpackPath(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+void unpackPath(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                 BidirectionalIterator packed_path_begin,
                 BidirectionalIterator packed_path_end,
                 Callback &&callback)
@@ -325,7 +324,7 @@ void unpackPath(const FacadeT &facade,
  * @param to the node the CH edge finishes at
  * @param unpacked_path the sequence of original NodeIDs that make up the expanded CH edge
  */
-void unpackEdge(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+void unpackEdge(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                 const NodeID from,
                 const NodeID to,
                 std::vector<NodeID> &unpacked_path);
@@ -351,7 +350,7 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData::QueryHeap &search_
 // && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
-void search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
             SearchEngineData::QueryHeap &forward_heap,
             SearchEngineData::QueryHeap &reverse_heap,
             std::int32_t &weight,
@@ -361,7 +360,7 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH>
             const int duration_upper_bound = INVALID_EDGE_WEIGHT);
 
 // Alias to be compatible with the overload for CoreCH that needs 4 heaps
-inline void search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+inline void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                    SearchEngineData::QueryHeap &forward_heap,
                    SearchEngineData::QueryHeap &reverse_heap,
                    SearchEngineData::QueryHeap &,
@@ -382,31 +381,11 @@ inline void search(const datafacade::ContiguousInternalMemoryDataFacade<algorith
            duration_upper_bound);
 }
 
-// assumes that heaps are already setup correctly.
-// A forced loop might be necessary, if source and target are on the same segment.
-// If this is the case and the offsets of the respective direction are larger for the source
-// than the target
-// then a force loop is required (e.g. source_phantom.forward_segment_id ==
-// target_phantom.forward_segment_id
-// && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
-// requires
-// a force loop, if the heaps have been initialized with positive offsets.
-void search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
-            SearchEngineData::QueryHeap &forward_heap,
-            SearchEngineData::QueryHeap &reverse_heap,
-            SearchEngineData::QueryHeap &forward_core_heap,
-            SearchEngineData::QueryHeap &reverse_core_heap,
-            int &weight,
-            std::vector<NodeID> &packed_leg,
-            const bool force_loop_forward,
-            const bool force_loop_reverse,
-            int duration_upper_bound = INVALID_EDGE_WEIGHT);
-
 bool needsLoopForward(const PhantomNode &source_phantom, const PhantomNode &target_phantom);
 
 bool needsLoopBackwards(const PhantomNode &source_phantom, const PhantomNode &target_phantom);
 
-double getPathDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+double getPathDistance(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
                        const std::vector<NodeID> &packed_path,
                        const PhantomNode &source_phantom,
                        const PhantomNode &target_phantom);
@@ -415,20 +394,7 @@ double getPathDistance(const datafacade::ContiguousInternalMemoryDataFacade<algo
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
 double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
-                   SearchEngineData::QueryHeap &forward_heap,
-                   SearchEngineData::QueryHeap &reverse_heap,
-                   SearchEngineData::QueryHeap &forward_core_heap,
-                   SearchEngineData::QueryHeap &reverse_core_heap,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   int duration_upper_bound = INVALID_EDGE_WEIGHT);
-
-// Requires the heaps for be empty
-// If heaps should be adjusted to be initialized outside of this function,
-// the addition of force_loop parameters might be required
-double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
                    SearchEngineData::QueryHeap &forward_heap,
                    SearchEngineData::QueryHeap &reverse_heap,
                    const PhantomNode &source_phantom,
@@ -437,7 +403,7 @@ getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorith
 
 // Alias to be compatible with the overload for CoreCH that needs 4 heaps
 inline double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
                    SearchEngineData::QueryHeap &forward_heap,
                    SearchEngineData::QueryHeap &reverse_heap,
                    SearchEngineData::QueryHeap &,
@@ -449,8 +415,44 @@ getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<algorith
     return getNetworkDistance(
         facade, forward_heap, reverse_heap, source_phantom, target_phantom, duration_upper_bound);
 }
-
 } // namespace ch
+
+namespace corech
+{
+// assumes that heaps are already setup correctly.
+// A forced loop might be necessary, if source and target are on the same segment.
+// If this is the case and the offsets of the respective direction are larger for the source
+// than the target
+// then a force loop is required (e.g. source_phantom.forward_segment_id ==
+// target_phantom.forward_segment_id
+// && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
+// requires
+// a force loop, if the heaps have been initialized with positive offsets.
+void search(const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+            SearchEngineData::QueryHeap &forward_heap,
+            SearchEngineData::QueryHeap &reverse_heap,
+            SearchEngineData::QueryHeap &forward_core_heap,
+            SearchEngineData::QueryHeap &reverse_core_heap,
+            int &weight,
+            std::vector<NodeID> &packed_leg,
+            const bool force_loop_forward,
+            const bool force_loop_reverse,
+            int duration_upper_bound = INVALID_EDGE_WEIGHT);
+
+// Requires the heaps for be empty
+// If heaps should be adjusted to be initialized outside of this function,
+// the addition of force_loop parameters might be required
+double
+getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+                   SearchEngineData::QueryHeap &forward_heap,
+                   SearchEngineData::QueryHeap &reverse_heap,
+                   SearchEngineData::QueryHeap &forward_core_heap,
+                   SearchEngineData::QueryHeap &reverse_core_heap,
+                   const PhantomNode &source_phantom,
+                   const PhantomNode &target_phantom,
+                   int duration_upper_bound = INVALID_EDGE_WEIGHT);
+} // namespace corech
+
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -57,7 +57,7 @@ bool checkParentCellRestriction(CellID cell, LevelID, CellID parent) { return ce
 }
 
 template <bool DIRECTION, typename... Args>
-void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::MLD> &facade,
+void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                  SearchEngineData::MultiLayerDijkstraHeap &forward_heap,
                  SearchEngineData::MultiLayerDijkstraHeap &reverse_heap,
                  NodeID &middle_node,
@@ -171,7 +171,7 @@ void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<algorithm:
 
 template <typename... Args>
 std::tuple<EdgeWeight, NodeID, NodeID, std::vector<EdgeID>>
-search(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::MLD> &facade,
+search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
        SearchEngineData::MultiLayerDijkstraHeap &forward_heap,
        SearchEngineData::MultiLayerDijkstraHeap &reverse_heap,
        Args... args)

include/engine/routing_algorithms/shortest_path.hpp

@@ -15,13 +15,13 @@ namespace routing_algorithms
 
 InternalRouteResult
 shortestPathSearch(SearchEngineData &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+                   const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
                    const boost::optional<bool> continue_straight_at_waypoint);
 
 InternalRouteResult
 shortestPathSearch(SearchEngineData &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CoreCH> &facade,
+                   const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
                    const boost::optional<bool> continue_straight_at_waypoint);
 

include/engine/routing_algorithms/tile_turns.hpp

@@ -29,7 +29,7 @@ struct TurnData final
 using RTreeLeaf = datafacade::BaseDataFacade::RTreeLeaf;
 
 std::vector<TurnData>
-getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
+getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
              const std::vector<RTreeLeaf> &edges,
              const std::vector<std::size_t> &sorted_edge_indexes);