From 49f0b1eb59398ca275bc76b25d19ac876f994371 Mon Sep 17 00:00:00 2001
From: Patrick Niklaus <patrick.niklaus@student.kit.edu>
Date: Thu, 13 Jul 2017 13:05:08 +0000
Subject: [PATCH] Add abstraction to change the data facade at compile time

---
 include/engine/datafacade.hpp                 | 26 ++++++++++
 include/engine/datafacade_provider.hpp        | 45 +++++++++-------
 include/engine/engine.hpp                     | 30 +++++------
 include/engine/plugins/match.hpp              |  3 +-
 include/engine/plugins/nearest.hpp            |  3 +-
 include/engine/plugins/table.hpp              |  3 +-
 include/engine/plugins/tile.hpp               |  3 +-
 include/engine/plugins/trip.hpp               |  3 +-
 include/engine/plugins/viaroute.hpp           |  3 +-
 include/engine/routing_algorithms.hpp         | 22 ++++----
 .../routing_algorithms/alternative_path.hpp   | 20 ++++----
 .../direct_shortest_path.hpp                  |  9 ++--
 .../routing_algorithms/many_to_many.hpp       | 13 +++--
 .../routing_algorithms/map_matching.hpp       |  4 +-
 .../routing_algorithms/routing_base.hpp       | 15 +++---
 .../routing_algorithms/routing_base_ch.hpp    | 49 +++++++++---------
 .../routing_algorithms/routing_base_mld.hpp   | 23 ++++-----
 .../routing_algorithms/shortest_path.hpp      |  9 ++--
 .../engine/routing_algorithms/tile_turns.hpp  | 17 +++----
 src/engine/plugins/match.cpp                  |  5 +-
 src/engine/plugins/nearest.cpp                | 10 ++--
 src/engine/plugins/table.cpp                  |  4 +-
 src/engine/plugins/tile.cpp                   | 11 ++--
 src/engine/plugins/trip.cpp                   |  4 +-
 src/engine/plugins/viaroute.cpp               |  9 ++--
 .../alternative_path_ch.cpp                   | 51 +++++++++----------
 .../alternative_path_mld.cpp                  |  2 +-
 .../direct_shortest_path.cpp                  | 30 +++++------
 .../routing_algorithms/many_to_many.cpp       | 49 ++++++++----------
 .../routing_algorithms/map_matching.cpp       |  8 +--
 .../routing_algorithms/routing_base_ch.cpp    | 10 ++--
 .../routing_algorithms/shortest_path.cpp      | 21 ++++----
 src/engine/routing_algorithms/tile_turns.cpp  | 28 ++++------
 33 files changed, 267 insertions(+), 275 deletions(-)
 create mode 100644 include/engine/datafacade.hpp

diff --git a/include/engine/datafacade.hpp b/include/engine/datafacade.hpp
new file mode 100644
index 000000000..5da6210a0
--- /dev/null
+++ b/include/engine/datafacade.hpp
@@ -0,0 +1,26 @@
+#ifndef OSRM_ENGINE_DATAFACADE_DATAFACADE_HPP
+#define OSRM_ENGINE_DATAFACADE_DATAFACADE_HPP
+
+#ifdef OSRM_EXTERNAL_MEMORY
+
+// Register your own data backend here
+#error "No external memory implementation found"
+
+#else
+
+#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+
+namespace osrm
+{
+namespace engine
+{
+
+using DataFacadeBase = datafacade::ContiguousInternalMemoryDataFacadeBase;
+template <typename AlgorithmT>
+using DataFacade = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
+}
+}
+
+#endif
+
+#endif
diff --git a/include/engine/datafacade_provider.hpp b/include/engine/datafacade_provider.hpp
index 25b3a4edf..4b46bb942 100644
--- a/include/engine/datafacade_provider.hpp
+++ b/include/engine/datafacade_provider.hpp
@@ -2,6 +2,7 @@
 #define OSRM_ENGINE_DATAFACADE_PROVIDER_HPP
 
 #include "engine/data_watchdog.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
 #include "engine/datafacade/process_memory_allocator.hpp"
 
@@ -9,48 +10,56 @@ namespace osrm
 {
 namespace engine
 {
-
-template <typename AlgorithmT> class DataFacadeProvider
+namespace detail
 {
-    using FacadeT = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
 
+template <typename AlgorithmT, template <typename A> class FacadeT> class DataFacadeProvider
+{
   public:
+    using Facade = FacadeT<AlgorithmT>;
+
     virtual ~DataFacadeProvider() = default;
 
-    virtual std::shared_ptr<const FacadeT> Get() const = 0;
+    virtual std::shared_ptr<const Facade> Get() const = 0;
 };
 
-template <typename AlgorithmT> class ImmutableProvider final : public DataFacadeProvider<AlgorithmT>
+template <typename AlgorithmT, template <typename A> class FacadeT>
+class ImmutableProvider final : public DataFacadeProvider<AlgorithmT, FacadeT>
 {
-    using FacadeT = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
-
   public:
+    using Facade = typename DataFacadeProvider<AlgorithmT, FacadeT>::Facade;
+
     ImmutableProvider(const storage::StorageConfig &config)
-        : immutable_data_facade(std::make_shared<FacadeT>(
+        : immutable_data_facade(std::make_shared<Facade>(
               std::make_shared<datafacade::ProcessMemoryAllocator>(config)))
     {
     }
 
-    std::shared_ptr<const FacadeT> Get() const override final { return immutable_data_facade; }
+    std::shared_ptr<const Facade> Get() const override final { return immutable_data_facade; }
 
   private:
-    std::shared_ptr<const FacadeT> immutable_data_facade;
+    std::shared_ptr<const Facade> immutable_data_facade;
 };
 
-template <typename AlgorithmT> class WatchingProvider final : public DataFacadeProvider<AlgorithmT>
+template <typename AlgorithmT, template <typename A> class FacadeT>
+class WatchingProvider : public DataFacadeProvider<AlgorithmT, FacadeT>
 {
-    using FacadeT = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
     DataWatchdog<AlgorithmT> watchdog;
 
   public:
-    std::shared_ptr<const FacadeT> Get() const override final
-    {
-        // We need a singleton here because multiple instances of DataWatchdog
-        // conflict on shared memory mappings
-        return watchdog.Get();
-    }
+    using Facade = typename DataFacadeProvider<AlgorithmT, FacadeT>::Facade;
+
+    std::shared_ptr<const Facade> Get() const override final { return watchdog.Get(); }
 };
 }
+
+template <typename AlgorithmT>
+using DataFacadeProvider = detail::DataFacadeProvider<AlgorithmT, DataFacade>;
+template <typename AlgorithmT>
+using WatchingProvider = detail::WatchingProvider<AlgorithmT, DataFacade>;
+template <typename AlgorithmT>
+using ImmutableProvider = detail::ImmutableProvider<AlgorithmT, DataFacade>;
+}
 }
 
 #endif
diff --git a/include/engine/engine.hpp b/include/engine/engine.hpp
index cdb4b598e..bd7137131 100644
--- a/include/engine/engine.hpp
+++ b/include/engine/engine.hpp
@@ -85,47 +85,41 @@ template <typename Algorithm> class Engine final : public EngineInterface
     Status Route(const api::RouteParameters &params,
                  util::json::Object &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return route_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return route_plugin.HandleRequest(algorithms, params, result);
     }
 
     Status Table(const api::TableParameters &params,
                  util::json::Object &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return table_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return table_plugin.HandleRequest(algorithms, params, result);
     }
 
     Status Nearest(const api::NearestParameters &params,
                    util::json::Object &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return nearest_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return nearest_plugin.HandleRequest(algorithms, params, result);
     }
 
     Status Trip(const api::TripParameters &params, util::json::Object &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return trip_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return trip_plugin.HandleRequest(algorithms, params, result);
     }
 
     Status Match(const api::MatchParameters &params,
                  util::json::Object &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return match_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return match_plugin.HandleRequest(algorithms, params, result);
     }
 
     Status Tile(const api::TileParameters &params, std::string &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return tile_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return tile_plugin.HandleRequest(algorithms, params, result);
     }
 
     static bool CheckCompability(const EngineConfig &config);
diff --git a/include/engine/plugins/match.hpp b/include/engine/plugins/match.hpp
index 6459dffab..fd8dedf18 100644
--- a/include/engine/plugins/match.hpp
+++ b/include/engine/plugins/match.hpp
@@ -32,8 +32,7 @@ class MatchPlugin : public BasePlugin
     {
     }
 
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::MatchParameters &parameters,
                          util::json::Object &json_result) const;
 
diff --git a/include/engine/plugins/nearest.hpp b/include/engine/plugins/nearest.hpp
index 95a2021d4..ccc0a4cdd 100644
--- a/include/engine/plugins/nearest.hpp
+++ b/include/engine/plugins/nearest.hpp
@@ -19,8 +19,7 @@ class NearestPlugin final : public BasePlugin
   public:
     explicit NearestPlugin(const int max_results);
 
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::NearestParameters &params,
                          util::json::Object &result) const;
 
diff --git a/include/engine/plugins/table.hpp b/include/engine/plugins/table.hpp
index c2aca80a7..d31877c3c 100644
--- a/include/engine/plugins/table.hpp
+++ b/include/engine/plugins/table.hpp
@@ -21,8 +21,7 @@ class TablePlugin final : public BasePlugin
   public:
     explicit TablePlugin(const int max_locations_distance_table);
 
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::TableParameters &params,
                          util::json::Object &result) const;
 
diff --git a/include/engine/plugins/tile.hpp b/include/engine/plugins/tile.hpp
index f35ef98ea..24d141e35 100644
--- a/include/engine/plugins/tile.hpp
+++ b/include/engine/plugins/tile.hpp
@@ -26,8 +26,7 @@ namespace plugins
 class TilePlugin final : public BasePlugin
 {
   public:
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::TileParameters &parameters,
                          std::string &pbf_buffer) const;
 };
diff --git a/include/engine/plugins/trip.hpp b/include/engine/plugins/trip.hpp
index 15702ac59..d49126e19 100644
--- a/include/engine/plugins/trip.hpp
+++ b/include/engine/plugins/trip.hpp
@@ -38,8 +38,7 @@ class TripPlugin final : public BasePlugin
   public:
     explicit TripPlugin(const int max_locations_trip_) : max_locations_trip(max_locations_trip_) {}
 
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::TripParameters &parameters,
                          util::json::Object &json_result) const;
 };
diff --git a/include/engine/plugins/viaroute.hpp b/include/engine/plugins/viaroute.hpp
index 1e1234dea..1e64ec962 100644
--- a/include/engine/plugins/viaroute.hpp
+++ b/include/engine/plugins/viaroute.hpp
@@ -32,8 +32,7 @@ class ViaRoutePlugin final : public BasePlugin
   public:
     explicit ViaRoutePlugin(int max_locations_viaroute, int max_alternatives);
 
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::RouteParameters &route_parameters,
                          util::json::Object &json_result) const;
 };
diff --git a/include/engine/routing_algorithms.hpp b/include/engine/routing_algorithms.hpp
index bd1a44546..f503cb898 100644
--- a/include/engine/routing_algorithms.hpp
+++ b/include/engine/routing_algorithms.hpp
@@ -46,6 +46,8 @@ class RoutingAlgorithmsInterface
     GetTileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
                  const std::vector<std::size_t> &sorted_edge_indexes) const = 0;
 
+    virtual const DataFacadeBase &GetFacade() const = 0;
+
     virtual bool HasAlternativePathSearch() const = 0;
     virtual bool HasShortestPathSearch() const = 0;
     virtual bool HasDirectShortestPathSearch() const = 0;
@@ -59,7 +61,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
 {
   public:
     RoutingAlgorithms(SearchEngineData<Algorithm> &heaps,
-                      const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade)
+                      std::shared_ptr<const DataFacade<Algorithm>> facade)
         : heaps(heaps), facade(facade)
     {
     }
@@ -93,6 +95,8 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
     GetTileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
                  const std::vector<std::size_t> &sorted_edge_indexes) const final override;
 
+    const DataFacadeBase &GetFacade() const final override { return *facade; }
+
     bool HasAlternativePathSearch() const final override
     {
         return routing_algorithms::HasAlternativePathSearch<Algorithm>::value;
@@ -125,9 +129,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
 
   private:
     SearchEngineData<Algorithm> &heaps;
-
-    // Owned by shared-ptr passed to the query
-    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade;
+    std::shared_ptr<const DataFacade<Algorithm>> facade;
 };
 
 template <typename Algorithm>
@@ -136,7 +138,7 @@ RoutingAlgorithms<Algorithm>::AlternativePathSearch(const PhantomNodes &phantom_
                                                     unsigned number_of_alternatives) const
 {
     return routing_algorithms::alternativePathSearch(
-        heaps, facade, phantom_node_pair, number_of_alternatives);
+        heaps, *facade, phantom_node_pair, number_of_alternatives);
 }
 
 template <typename Algorithm>
@@ -145,14 +147,14 @@ InternalRouteResult RoutingAlgorithms<Algorithm>::ShortestPathSearch(
     const boost::optional<bool> continue_straight_at_waypoint) const
 {
     return routing_algorithms::shortestPathSearch(
-        heaps, facade, phantom_node_pair, continue_straight_at_waypoint);
+        heaps, *facade, phantom_node_pair, continue_straight_at_waypoint);
 }
 
 template <typename Algorithm>
 InternalRouteResult
 RoutingAlgorithms<Algorithm>::DirectShortestPathSearch(const PhantomNodes &phantom_nodes) const
 {
-    return routing_algorithms::directShortestPathSearch(heaps, facade, phantom_nodes);
+    return routing_algorithms::directShortestPathSearch(heaps, *facade, phantom_nodes);
 }
 
 template <typename Algorithm>
@@ -162,7 +164,7 @@ RoutingAlgorithms<Algorithm>::ManyToManySearch(const std::vector<PhantomNode> &p
                                                const std::vector<std::size_t> &target_indices) const
 {
     return routing_algorithms::manyToManySearch(
-        heaps, facade, phantom_nodes, source_indices, target_indices);
+        heaps, *facade, phantom_nodes, source_indices, target_indices);
 }
 
 template <typename Algorithm>
@@ -174,7 +176,7 @@ inline routing_algorithms::SubMatchingList RoutingAlgorithms<Algorithm>::MapMatc
     const bool allow_splitting) const
 {
     return routing_algorithms::mapMatching(heaps,
-                                           facade,
+                                           *facade,
                                            candidates_list,
                                            trace_coordinates,
                                            trace_timestamps,
@@ -187,7 +189,7 @@ inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<Algorithm>::G
     const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
     const std::vector<std::size_t> &sorted_edge_indexes) const
 {
-    return routing_algorithms::getTileTurns(facade, edges, sorted_edge_indexes);
+    return routing_algorithms::getTileTurns(*facade, edges, sorted_edge_indexes);
 }
 
 // CoreCH overrides
diff --git a/include/engine/routing_algorithms/alternative_path.hpp b/include/engine/routing_algorithms/alternative_path.hpp
index dff8d25c7..a7801349b 100644
--- a/include/engine/routing_algorithms/alternative_path.hpp
+++ b/include/engine/routing_algorithms/alternative_path.hpp
@@ -1,7 +1,7 @@
 #ifndef ALTERNATIVE_PATH_ROUTING_HPP
 #define ALTERNATIVE_PATH_ROUTING_HPP
 
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/internal_route_result.hpp"
 
 #include "engine/algorithm.hpp"
@@ -16,17 +16,15 @@ namespace engine
 namespace routing_algorithms
 {
 
-InternalManyRoutesResult
-alternativePathSearch(SearchEngineData<ch::Algorithm> &search_engine_data,
-                      const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-                      const PhantomNodes &phantom_node_pair,
-                      unsigned number_of_alternatives);
+InternalManyRoutesResult alternativePathSearch(SearchEngineData<ch::Algorithm> &search_engine_data,
+                                               const DataFacade<ch::Algorithm> &facade,
+                                               const PhantomNodes &phantom_node_pair,
+                                               unsigned number_of_alternatives);
 
-InternalManyRoutesResult
-alternativePathSearch(SearchEngineData<mld::Algorithm> &search_engine_data,
-                      const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-                      const PhantomNodes &phantom_node_pair,
-                      unsigned number_of_alternatives);
+InternalManyRoutesResult alternativePathSearch(SearchEngineData<mld::Algorithm> &search_engine_data,
+                                               const DataFacade<mld::Algorithm> &facade,
+                                               const PhantomNodes &phantom_node_pair,
+                                               unsigned number_of_alternatives);
 
 } // namespace routing_algorithms
 } // namespace engine
diff --git a/include/engine/routing_algorithms/direct_shortest_path.hpp b/include/engine/routing_algorithms/direct_shortest_path.hpp
index 6cc5cc488..476ee2e2d 100644
--- a/include/engine/routing_algorithms/direct_shortest_path.hpp
+++ b/include/engine/routing_algorithms/direct_shortest_path.hpp
@@ -2,7 +2,7 @@
 #define DIRECT_SHORTEST_PATH_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/internal_route_result.hpp"
 #include "engine/search_engine_data.hpp"
 
@@ -22,10 +22,9 @@ namespace routing_algorithms
 /// This variation is only an optimazation for graphs with slow queries, for example
 /// not fully contracted graphs.
 template <typename Algorithm>
-InternalRouteResult
-directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                         const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                         const PhantomNodes &phantom_nodes);
+InternalRouteResult directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                             const DataFacade<Algorithm> &facade,
+                                             const PhantomNodes &phantom_nodes);
 
 } // namespace routing_algorithms
 } // namespace engine
diff --git a/include/engine/routing_algorithms/many_to_many.hpp b/include/engine/routing_algorithms/many_to_many.hpp
index a043aee33..abaddce19 100644
--- a/include/engine/routing_algorithms/many_to_many.hpp
+++ b/include/engine/routing_algorithms/many_to_many.hpp
@@ -2,7 +2,7 @@
 #define MANY_TO_MANY_ROUTING_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/search_engine_data.hpp"
 
 #include "util/typedefs.hpp"
@@ -17,12 +17,11 @@ namespace routing_algorithms
 {
 
 template <typename Algorithm>
-std::vector<EdgeWeight>
-manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
-                 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);
+std::vector<EdgeWeight> manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
+                                         const DataFacade<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 routing_algorithms
 } // namespace engine
diff --git a/include/engine/routing_algorithms/map_matching.hpp b/include/engine/routing_algorithms/map_matching.hpp
index 98946337d..359a06340 100644
--- a/include/engine/routing_algorithms/map_matching.hpp
+++ b/include/engine/routing_algorithms/map_matching.hpp
@@ -2,7 +2,7 @@
 #define MAP_MATCHING_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/map_matching/sub_matching.hpp"
 #include "engine/search_engine_data.hpp"
 
@@ -24,7 +24,7 @@ static const constexpr double DEFAULT_GPS_PRECISION = 5;
 //     P. Newson and J. Krumm; 2009; ACM GIS
 template <typename Algorithm>
 SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
-                            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                            const DataFacade<Algorithm> &facade,
                             const CandidateLists &candidates_list,
                             const std::vector<util::Coordinate> &trace_coordinates,
                             const std::vector<unsigned> &trace_timestamps,
diff --git a/include/engine/routing_algorithms/routing_base.hpp b/include/engine/routing_algorithms/routing_base.hpp
index 17fde0205..3524adc8e 100644
--- a/include/engine/routing_algorithms/routing_base.hpp
+++ b/include/engine/routing_algorithms/routing_base.hpp
@@ -4,7 +4,7 @@
 #include "extractor/guidance/turn_instruction.hpp"
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/internal_route_result.hpp"
 #include "engine/phantom_node.hpp"
 #include "engine/search_engine_data.hpp"
@@ -320,7 +320,7 @@ void annotatePath(const FacadeT &facade,
 }
 
 template <typename Algorithm>
-double getPathDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+double getPathDistance(const DataFacade<Algorithm> &facade,
                        const std::vector<PathData> unpacked_path,
                        const PhantomNode &source_phantom,
                        const PhantomNode &target_phantom)
@@ -373,12 +373,11 @@ double getPathDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algo
 }
 
 template <typename AlgorithmT>
-InternalRouteResult
-extractRoute(const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &facade,
-             const EdgeWeight weight,
-             const PhantomNodes &phantom_nodes,
-             const std::vector<NodeID> &unpacked_nodes,
-             const std::vector<EdgeID> &unpacked_edges)
+InternalRouteResult extractRoute(const DataFacade<AlgorithmT> &facade,
+                                 const EdgeWeight weight,
+                                 const PhantomNodes &phantom_nodes,
+                                 const std::vector<NodeID> &unpacked_nodes,
+                                 const std::vector<EdgeID> &unpacked_edges)
 {
     InternalRouteResult raw_route_data;
     raw_route_data.segment_end_coordinates = {phantom_nodes};
diff --git a/include/engine/routing_algorithms/routing_base_ch.hpp b/include/engine/routing_algorithms/routing_base_ch.hpp
index 0ac059b84..99e38a7f3 100644
--- a/include/engine/routing_algorithms/routing_base_ch.hpp
+++ b/include/engine/routing_algorithms/routing_base_ch.hpp
@@ -2,7 +2,7 @@
 #define OSRM_ENGINE_ROUTING_BASE_CH_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/routing_algorithms/routing_base.hpp"
 #include "engine/search_engine_data.hpp"
 
@@ -23,7 +23,7 @@ namespace ch
 
 // Stalling
 template <bool DIRECTION, typename HeapT>
-bool stallAtNode(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+bool stallAtNode(const DataFacade<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> &facade,
+void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         SearchEngineData<Algorithm>::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> &facade,
+void routingStep(const DataFacade<Algorithm> &facade,
                  SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                  SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                  NodeID &middle_node_id,
@@ -186,8 +186,7 @@ void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
 }
 
 template <bool UseDuration>
-EdgeWeight getLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                         NodeID node)
+EdgeWeight getLoopWeight(const DataFacade<Algorithm> &facade, NodeID node)
 {
     EdgeWeight loop_weight = UseDuration ? MAXIMAL_EDGE_DURATION : INVALID_EDGE_WEIGHT;
     for (auto edge : facade.GetAdjacentEdgeRange(node))
@@ -227,7 +226,7 @@ EdgeWeight getLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<Al
  * original edge found.
  */
 template <typename BidirectionalIterator, typename Callback>
-void unpackPath(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void unpackPath(const DataFacade<Algorithm> &facade,
                 BidirectionalIterator packed_path_begin,
                 BidirectionalIterator packed_path_end,
                 Callback &&callback)
@@ -327,7 +326,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> &facade,
+void unpackEdge(const DataFacade<Algorithm> &facade,
                 const NodeID from,
                 const NodeID to,
                 std::vector<NodeID> &unpacked_path);
@@ -354,7 +353,7 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHe
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
 void search(SearchEngineData<Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+            const DataFacade<Algorithm> &facade,
             SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             std::int32_t &weight,
@@ -367,14 +366,13 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
 // 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(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   int duration_upper_bound = INVALID_EDGE_WEIGHT);
+double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                          const DataFacade<ch::Algorithm> &facade,
+                          SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                          SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                          const PhantomNode &source_phantom,
+                          const PhantomNode &target_phantom,
+                          int duration_upper_bound = INVALID_EDGE_WEIGHT);
 
 } // namespace ch
 
@@ -390,7 +388,7 @@ namespace corech
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
 void search(SearchEngineData<Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+            const DataFacade<corech::Algorithm> &facade,
             SearchEngineData<ch::Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<ch::Algorithm>::QueryHeap &reverse_heap,
             int &weight,
@@ -403,14 +401,13 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
 // 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(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
-                   SearchEngineData<ch::Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<ch::Algorithm>::QueryHeap &reverse_heap,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   int duration_upper_bound = INVALID_EDGE_WEIGHT);
+double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                          const DataFacade<corech::Algorithm> &facade,
+                          SearchEngineData<ch::Algorithm>::QueryHeap &forward_heap,
+                          SearchEngineData<ch::Algorithm>::QueryHeap &reverse_heap,
+                          const PhantomNode &source_phantom,
+                          const PhantomNode &target_phantom,
+                          int duration_upper_bound = INVALID_EDGE_WEIGHT);
 
 template <typename RandomIter, typename FacadeT>
 void unpackPath(const FacadeT &facade,
diff --git a/include/engine/routing_algorithms/routing_base_mld.hpp b/include/engine/routing_algorithms/routing_base_mld.hpp
index 22192f0a7..102a8f8ed 100644
--- a/include/engine/routing_algorithms/routing_base_mld.hpp
+++ b/include/engine/routing_algorithms/routing_base_mld.hpp
@@ -2,7 +2,7 @@
 #define OSRM_ENGINE_ROUTING_BASE_MLD_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/routing_algorithms/routing_base.hpp"
 #include "engine/search_engine_data.hpp"
 
@@ -131,7 +131,7 @@ retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward
 }
 
 template <bool DIRECTION, typename... Args>
-void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void routingStep(const DataFacade<Algorithm> &facade,
                  SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                  SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                  NodeID &middle_node,
@@ -262,7 +262,7 @@ using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
 
 template <typename... Args>
 UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
-                    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                    const DataFacade<Algorithm> &facade,
                     SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                     SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                     const bool force_loop_forward,
@@ -390,7 +390,7 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
 
 // Alias to be compatible with the CH-based search
 inline void search(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                   const DataFacade<Algorithm> &facade,
                    SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                    SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                    EdgeWeight &weight,
@@ -442,14 +442,13 @@ void unpackPath(const FacadeT &facade,
     annotatePath(facade, phantom_nodes, unpacked_nodes, unpacked_edges, unpacked_path);
 }
 
-inline double
-getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
+inline double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                                 const DataFacade<Algorithm> &facade,
+                                 SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                                 SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                                 const PhantomNode &source_phantom,
+                                 const PhantomNode &target_phantom,
+                                 EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
     forward_heap.Clear();
     reverse_heap.Clear();
diff --git a/include/engine/routing_algorithms/shortest_path.hpp b/include/engine/routing_algorithms/shortest_path.hpp
index ca0c6d21d..8c9e0159d 100644
--- a/include/engine/routing_algorithms/shortest_path.hpp
+++ b/include/engine/routing_algorithms/shortest_path.hpp
@@ -14,11 +14,10 @@ namespace routing_algorithms
 {
 
 template <typename Algorithm>
-InternalRouteResult
-shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   const std::vector<PhantomNodes> &phantom_nodes_vector,
-                   const boost::optional<bool> continue_straight_at_waypoint);
+InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                       const DataFacade<Algorithm> &facade,
+                                       const std::vector<PhantomNodes> &phantom_nodes_vector,
+                                       const boost::optional<bool> continue_straight_at_waypoint);
 
 } // namespace routing_algorithms
 } // namespace engine
diff --git a/include/engine/routing_algorithms/tile_turns.hpp b/include/engine/routing_algorithms/tile_turns.hpp
index 676ebdf3a..0464f9279 100644
--- a/include/engine/routing_algorithms/tile_turns.hpp
+++ b/include/engine/routing_algorithms/tile_turns.hpp
@@ -2,7 +2,8 @@
 #define OSRM_ENGINE_ROUTING_ALGORITHMS_TILE_TURNS_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
+#include "engine/datafacade/datafacade_base.hpp"
 
 #include "util/coordinate.hpp"
 #include "util/typedefs.hpp"
@@ -28,15 +29,13 @@ struct TurnData final
 
 using RTreeLeaf = datafacade::BaseDataFacade::RTreeLeaf;
 
-std::vector<TurnData>
-getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-             const std::vector<RTreeLeaf> &edges,
-             const std::vector<std::size_t> &sorted_edge_indexes);
+std::vector<TurnData> getTileTurns(const DataFacade<ch::Algorithm> &facade,
+                                   const std::vector<RTreeLeaf> &edges,
+                                   const std::vector<std::size_t> &sorted_edge_indexes);
 
-std::vector<TurnData>
-getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-             const std::vector<RTreeLeaf> &edges,
-             const std::vector<std::size_t> &sorted_edge_indexes);
+std::vector<TurnData> getTileTurns(const DataFacade<mld::Algorithm> &facade,
+                                   const std::vector<RTreeLeaf> &edges,
+                                   const std::vector<std::size_t> &sorted_edge_indexes);
 
 } // namespace routing_algorithms
 } // namespace engine
diff --git a/src/engine/plugins/match.cpp b/src/engine/plugins/match.cpp
index 5cd2b3736..fd1e4c775 100644
--- a/src/engine/plugins/match.cpp
+++ b/src/engine/plugins/match.cpp
@@ -109,8 +109,7 @@ void filterCandidates(const std::vector<util::Coordinate> &coordinates,
     }
 }
 
-Status MatchPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                                  const RoutingAlgorithmsInterface &algorithms,
+Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                                   const api::MatchParameters &parameters,
                                   util::json::Object &json_result) const
 {
@@ -121,6 +120,8 @@ Status MatchPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
                      json_result);
     }
 
+    const auto &facade = algorithms.GetFacade();
+
     BOOST_ASSERT(parameters.IsValid());
 
     // enforce maximum number of locations for performance reasons
diff --git a/src/engine/plugins/nearest.cpp b/src/engine/plugins/nearest.cpp
index ad2142a45..f8ede3b33 100644
--- a/src/engine/plugins/nearest.cpp
+++ b/src/engine/plugins/nearest.cpp
@@ -19,14 +19,14 @@ namespace plugins
 
 NearestPlugin::NearestPlugin(const int max_results_) : max_results{max_results_} {}
 
-Status
-NearestPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                             const RoutingAlgorithmsInterface & /*algorithms*/,
-                             const api::NearestParameters &params,
-                             util::json::Object &json_result) const
+Status NearestPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
+                                    const api::NearestParameters &params,
+                                    util::json::Object &json_result) const
 {
     BOOST_ASSERT(params.IsValid());
 
+    const auto &facade = algorithms.GetFacade();
+
     if (max_results > 0 &&
         (boost::numeric_cast<std::int64_t>(params.number_of_results) > max_results))
     {
diff --git a/src/engine/plugins/table.cpp b/src/engine/plugins/table.cpp
index 4448b98df..5f524499e 100644
--- a/src/engine/plugins/table.cpp
+++ b/src/engine/plugins/table.cpp
@@ -28,8 +28,7 @@ TablePlugin::TablePlugin(const int max_locations_distance_table)
 {
 }
 
-Status TablePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                                  const RoutingAlgorithmsInterface &algorithms,
+Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                                   const api::TableParameters &params,
                                   util::json::Object &result) const
 {
@@ -67,6 +66,7 @@ Status TablePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
         return Error("TooBig", "Too many table coordinates", result);
     }
 
+    const auto &facade = algorithms.GetFacade();
     auto phantom_nodes = GetPhantomNodes(facade, params);
 
     if (phantom_nodes.size() != params.coordinates.size())
diff --git a/src/engine/plugins/tile.cpp b/src/engine/plugins/tile.cpp
index 80e027971..fc38f592b 100644
--- a/src/engine/plugins/tile.cpp
+++ b/src/engine/plugins/tile.cpp
@@ -230,10 +230,7 @@ FixedPoint coordinatesToTilePoint(const util::Coordinate point, const BBox &tile
     return FixedPoint{px, py};
 }
 
-std::vector<RTreeLeaf> getEdges(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                                unsigned x,
-                                unsigned y,
-                                unsigned z)
+std::vector<RTreeLeaf> getEdges(const DataFacadeBase &facade, unsigned x, unsigned y, unsigned z)
 {
     double min_lon, min_lat, max_lon, max_lat;
 
@@ -274,7 +271,7 @@ std::vector<std::size_t> getEdgeIndex(const std::vector<RTreeLeaf> &edges)
     return sorted_edge_indexes;
 }
 
-void encodeVectorTile(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
+void encodeVectorTile(const DataFacadeBase &facade,
                       unsigned x,
                       unsigned y,
                       unsigned z,
@@ -882,13 +879,13 @@ void encodeVectorTile(const datafacade::ContiguousInternalMemoryDataFacadeBase &
 }
 }
 
-Status TilePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                                 const RoutingAlgorithmsInterface &algorithms,
+Status TilePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                                  const api::TileParameters &parameters,
                                  std::string &pbf_buffer) const
 {
     BOOST_ASSERT(parameters.IsValid());
 
+    const auto &facade = algorithms.GetFacade();
     auto edges = getEdges(facade, parameters.x, parameters.y, parameters.z);
 
     auto edge_index = getEdgeIndex(edges);
diff --git a/src/engine/plugins/trip.cpp b/src/engine/plugins/trip.cpp
index 2346a765e..5d5f6a487 100644
--- a/src/engine/plugins/trip.cpp
+++ b/src/engine/plugins/trip.cpp
@@ -142,8 +142,7 @@ void ManipulateTableForFSE(const std::size_t source_id,
     //*********  End of changes to table  *************************************
 }
 
-Status TripPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                                 const RoutingAlgorithmsInterface &algorithms,
+Status TripPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                                  const api::TripParameters &parameters,
                                  util::json::Object &json_result) const
 {
@@ -192,6 +191,7 @@ Status TripPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataF
         return Error("InvalidValue", "Invalid coordinate value.", json_result);
     }
 
+    const auto &facade = algorithms.GetFacade();
     auto phantom_node_pairs = GetPhantomNodes(facade, parameters);
     if (phantom_node_pairs.size() != number_of_locations)
     {
diff --git a/src/engine/plugins/viaroute.cpp b/src/engine/plugins/viaroute.cpp
index c80c0411b..0740d70aa 100644
--- a/src/engine/plugins/viaroute.cpp
+++ b/src/engine/plugins/viaroute.cpp
@@ -26,11 +26,9 @@ ViaRoutePlugin::ViaRoutePlugin(int max_locations_viaroute, int max_alternatives)
 {
 }
 
-Status
-ViaRoutePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                              const RoutingAlgorithmsInterface &algorithms,
-                              const api::RouteParameters &route_parameters,
-                              util::json::Object &json_result) const
+Status ViaRoutePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
+                                     const api::RouteParameters &route_parameters,
+                                     util::json::Object &json_result) const
 {
     BOOST_ASSERT(route_parameters.IsValid());
 
@@ -75,6 +73,7 @@ ViaRoutePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFaca
         return Error("InvalidValue", "Invalid coordinate value.", json_result);
     }
 
+    const auto &facade = algorithms.GetFacade();
     auto phantom_node_pairs = GetPhantomNodes(facade, route_parameters);
     if (phantom_node_pairs.size() != route_parameters.coordinates.size())
     {
diff --git a/src/engine/routing_algorithms/alternative_path_ch.cpp b/src/engine/routing_algorithms/alternative_path_ch.cpp
index a738aa415..0fafa2447 100644
--- a/src/engine/routing_algorithms/alternative_path_ch.cpp
+++ b/src/engine/routing_algorithms/alternative_path_ch.cpp
@@ -50,7 +50,7 @@ struct RankedCandidateNode
 
 // todo: reorder parameters
 template <bool DIRECTION>
-void alternativeRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void alternativeRoutingStep(const DataFacade<Algorithm> &facade,
                             QueryHeap &heap1,
                             QueryHeap &heap2,
                             NodeID *middle_node,
@@ -153,14 +153,13 @@ void retrievePackedAlternatePath(const QueryHeap &forward_heap1,
 // compute and unpack <s,..,v> and <v,..,t> by exploring search spaces
 // from v and intersecting against queues. only half-searches have to be
 // done at this stage
-void computeWeightAndSharingOfViaPath(
-    SearchEngineData<Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-    const NodeID via_node,
-    EdgeWeight *real_weight_of_via_path,
-    EdgeWeight *sharing_of_via_path,
-    const std::vector<NodeID> &packed_shortest_path,
-    const EdgeWeight min_edge_offset)
+void computeWeightAndSharingOfViaPath(SearchEngineData<Algorithm> &engine_working_data,
+                                      const DataFacade<Algorithm> &facade,
+                                      const NodeID via_node,
+                                      EdgeWeight *real_weight_of_via_path,
+                                      EdgeWeight *sharing_of_via_path,
+                                      const std::vector<NodeID> &packed_shortest_path,
+                                      const EdgeWeight min_edge_offset)
 {
     engine_working_data.InitializeOrClearSecondThreadLocalStorage(facade.GetNumberOfNodes());
 
@@ -318,19 +317,18 @@ void computeWeightAndSharingOfViaPath(
 }
 
 // conduct T-Test
-bool viaNodeCandidatePassesTTest(
-    SearchEngineData<Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-    QueryHeap &existing_forward_heap,
-    QueryHeap &existing_reverse_heap,
-    QueryHeap &new_forward_heap,
-    QueryHeap &new_reverse_heap,
-    const RankedCandidateNode &candidate,
-    const EdgeWeight weight_of_shortest_path,
-    EdgeWeight *weight_of_via_path,
-    NodeID *s_v_middle,
-    NodeID *v_t_middle,
-    const EdgeWeight min_edge_offset)
+bool viaNodeCandidatePassesTTest(SearchEngineData<Algorithm> &engine_working_data,
+                                 const DataFacade<Algorithm> &facade,
+                                 QueryHeap &existing_forward_heap,
+                                 QueryHeap &existing_reverse_heap,
+                                 QueryHeap &new_forward_heap,
+                                 QueryHeap &new_reverse_heap,
+                                 const RankedCandidateNode &candidate,
+                                 const EdgeWeight weight_of_shortest_path,
+                                 EdgeWeight *weight_of_via_path,
+                                 NodeID *s_v_middle,
+                                 NodeID *v_t_middle,
+                                 const EdgeWeight min_edge_offset)
 {
     new_forward_heap.Clear();
     new_reverse_heap.Clear();
@@ -562,11 +560,10 @@ bool viaNodeCandidatePassesTTest(
 }
 } // anon. namespace
 
-InternalManyRoutesResult
-alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                      const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                      const PhantomNodes &phantom_node_pair,
-                      unsigned /*number_of_alternatives*/)
+InternalManyRoutesResult alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                               const DataFacade<Algorithm> &facade,
+                                               const PhantomNodes &phantom_node_pair,
+                                               unsigned /*number_of_alternatives*/)
 {
     InternalRouteResult primary_route;
     InternalRouteResult secondary_route;
diff --git a/src/engine/routing_algorithms/alternative_path_mld.cpp b/src/engine/routing_algorithms/alternative_path_mld.cpp
index 83f4a8e9b..5d87f2cad 100644
--- a/src/engine/routing_algorithms/alternative_path_mld.cpp
+++ b/src/engine/routing_algorithms/alternative_path_mld.cpp
@@ -28,7 +28,7 @@ using namespace mld;
 
 using Heap = SearchEngineData<Algorithm>::QueryHeap;
 using Partition = partition::MultiLevelPartitionView;
-using Facade = datafacade::ContiguousInternalMemoryDataFacade<Algorithm>;
+using Facade = DataFacade<Algorithm>;
 
 // Implementation details
 namespace
diff --git a/src/engine/routing_algorithms/direct_shortest_path.cpp b/src/engine/routing_algorithms/direct_shortest_path.cpp
index 9927cffec..d5a07a8a0 100644
--- a/src/engine/routing_algorithms/direct_shortest_path.cpp
+++ b/src/engine/routing_algorithms/direct_shortest_path.cpp
@@ -18,10 +18,9 @@ namespace routing_algorithms
 /// This variation is only an optimazation for graphs with slow queries, for example
 /// not fully contracted graphs.
 template <typename Algorithm>
-InternalRouteResult
-directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                         const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                         const PhantomNodes &phantom_nodes)
+InternalRouteResult directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                             const DataFacade<Algorithm> &facade,
+                                             const PhantomNodes &phantom_nodes)
 {
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
     auto &forward_heap = *engine_working_data.forward_heap_1;
@@ -65,21 +64,20 @@ directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
     return extractRoute(facade, weight, phantom_nodes, unpacked_nodes, unpacked_edges);
 }
 
-template InternalRouteResult directShortestPathSearch(
-    SearchEngineData<corech::Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
-    const PhantomNodes &phantom_nodes);
+template InternalRouteResult
+directShortestPathSearch(SearchEngineData<corech::Algorithm> &engine_working_data,
+                         const DataFacade<corech::Algorithm> &facade,
+                         const PhantomNodes &phantom_nodes);
 
-template InternalRouteResult directShortestPathSearch(
-    SearchEngineData<ch::Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-    const PhantomNodes &phantom_nodes);
+template InternalRouteResult
+directShortestPathSearch(SearchEngineData<ch::Algorithm> &engine_working_data,
+                         const DataFacade<ch::Algorithm> &facade,
+                         const PhantomNodes &phantom_nodes);
 
 template <>
-InternalRouteResult directShortestPathSearch(
-    SearchEngineData<mld::Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-    const PhantomNodes &phantom_nodes)
+InternalRouteResult directShortestPathSearch(SearchEngineData<mld::Algorithm> &engine_working_data,
+                                             const DataFacade<mld::Algorithm> &facade,
+                                             const PhantomNodes &phantom_nodes)
 {
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
     auto &forward_heap = *engine_working_data.forward_heap_1;
diff --git a/src/engine/routing_algorithms/many_to_many.cpp b/src/engine/routing_algorithms/many_to_many.cpp
index f7619757d..f272ca6f2 100644
--- a/src/engine/routing_algorithms/many_to_many.cpp
+++ b/src/engine/routing_algorithms/many_to_many.cpp
@@ -31,11 +31,10 @@ struct NodeBucket
 // FIXME This should be replaced by an std::unordered_multimap, though this needs benchmarking
 using SearchSpaceWithBuckets = std::unordered_map<NodeID, std::vector<NodeBucket>>;
 
-inline bool
-addLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-              const NodeID node,
-              EdgeWeight &weight,
-              EdgeDuration &duration)
+inline bool addLoopWeight(const DataFacade<ch::Algorithm> &facade,
+                          const NodeID node,
+                          EdgeWeight &weight,
+                          EdgeDuration &duration)
 { // Special case for CH when contractor creates a loop edge node->node
     BOOST_ASSERT(weight < 0);
 
@@ -56,7 +55,7 @@ addLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm
 }
 
 template <bool DIRECTION>
-void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+void relaxOutgoingEdges(const DataFacade<ch::Algorithm> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         const EdgeDuration duration,
@@ -97,22 +96,19 @@ void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<ch:
     }
 }
 
-inline bool addLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &,
-                          const NodeID,
-                          EdgeWeight &,
-                          EdgeDuration &)
+inline bool
+addLoopWeight(const DataFacade<mld::Algorithm> &, const NodeID, EdgeWeight &, EdgeDuration &)
 { // MLD overlay does not introduce loop edges
     return false;
 }
 
 template <bool DIRECTION>
-void relaxOutgoingEdges(
-    const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-    const NodeID node,
-    const EdgeWeight weight,
-    const EdgeDuration duration,
-    typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
-    const PhantomNode &phantom_node)
+void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
+                        const NodeID node,
+                        const EdgeWeight weight,
+                        const EdgeDuration duration,
+                        typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
+                        const PhantomNode &phantom_node)
 {
     const auto &partition = facade.GetMultiLevelPartition();
     const auto &cells = facade.GetCellStorage();
@@ -218,7 +214,7 @@ void relaxOutgoingEdges(
 }
 
 template <typename Algorithm>
-void forwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                         const unsigned row_idx,
                         const unsigned number_of_targets,
                         typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &query_heap,
@@ -272,7 +268,7 @@ void forwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Alg
 }
 
 template <typename Algorithm>
-void backwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void backwardRoutingStep(const DataFacade<Algorithm> &facade,
                          const unsigned column_idx,
                          typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &query_heap,
                          SearchSpaceWithBuckets &search_space_with_buckets,
@@ -291,12 +287,11 @@ void backwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Al
 }
 
 template <typename Algorithm>
-std::vector<EdgeWeight>
-manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
-                 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)
+std::vector<EdgeWeight> manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
+                                         const DataFacade<Algorithm> &facade,
+                                         const std::vector<PhantomNode> &phantom_nodes,
+                                         const std::vector<std::size_t> &source_indices,
+                                         const std::vector<std::size_t> &target_indices)
 {
     const auto number_of_sources =
         source_indices.empty() ? phantom_nodes.size() : source_indices.size();
@@ -386,14 +381,14 @@ manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
 
 template std::vector<EdgeWeight>
 manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
-                 const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+                 const DataFacade<ch::Algorithm> &facade,
                  const std::vector<PhantomNode> &phantom_nodes,
                  const std::vector<std::size_t> &source_indices,
                  const std::vector<std::size_t> &target_indices);
 
 template std::vector<EdgeWeight>
 manyToManySearch(SearchEngineData<mld::Algorithm> &engine_working_data,
-                 const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
+                 const DataFacade<mld::Algorithm> &facade,
                  const std::vector<PhantomNode> &phantom_nodes,
                  const std::vector<std::size_t> &source_indices,
                  const std::vector<std::size_t> &target_indices);
diff --git a/src/engine/routing_algorithms/map_matching.cpp b/src/engine/routing_algorithms/map_matching.cpp
index c06a2ff44..d1d5bb00d 100644
--- a/src/engine/routing_algorithms/map_matching.cpp
+++ b/src/engine/routing_algorithms/map_matching.cpp
@@ -50,7 +50,7 @@ unsigned getMedianSampleTime(const std::vector<unsigned> &timestamps)
 
 template <typename Algorithm>
 SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
-                            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                            const DataFacade<Algorithm> &facade,
                             const CandidateLists &candidates_list,
                             const std::vector<util::Coordinate> &trace_coordinates,
                             const std::vector<unsigned> &trace_timestamps,
@@ -422,7 +422,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
 
 template SubMatchingList
 mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+            const DataFacade<ch::Algorithm> &facade,
             const CandidateLists &candidates_list,
             const std::vector<util::Coordinate> &trace_coordinates,
             const std::vector<unsigned> &trace_timestamps,
@@ -431,7 +431,7 @@ mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
 
 template SubMatchingList
 mapMatching(SearchEngineData<corech::Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+            const DataFacade<corech::Algorithm> &facade,
             const CandidateLists &candidates_list,
             const std::vector<util::Coordinate> &trace_coordinates,
             const std::vector<unsigned> &trace_timestamps,
@@ -440,7 +440,7 @@ mapMatching(SearchEngineData<corech::Algorithm> &engine_working_data,
 
 template SubMatchingList
 mapMatching(SearchEngineData<mld::Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
+            const DataFacade<mld::Algorithm> &facade,
             const CandidateLists &candidates_list,
             const std::vector<util::Coordinate> &trace_coordinates,
             const std::vector<unsigned> &trace_timestamps,
diff --git a/src/engine/routing_algorithms/routing_base_ch.cpp b/src/engine/routing_algorithms/routing_base_ch.cpp
index b693f4330..5f228a111 100644
--- a/src/engine/routing_algorithms/routing_base_ch.cpp
+++ b/src/engine/routing_algorithms/routing_base_ch.cpp
@@ -16,7 +16,7 @@ namespace ch
  * @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> &facade,
+void unpackEdge(const DataFacade<Algorithm> &facade,
                 const NodeID from,
                 const NodeID to,
                 std::vector<NodeID> &unpacked_path)
@@ -72,7 +72,7 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHe
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
 void search(SearchEngineData<Algorithm> & /*engine_working_data*/,
-            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+            const DataFacade<Algorithm> &facade,
             SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             EdgeWeight &weight,
@@ -151,7 +151,7 @@ void search(SearchEngineData<Algorithm> & /*engine_working_data*/,
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
 double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
-                          const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                          const DataFacade<Algorithm> &facade,
                           SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                           SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                           const PhantomNode &source_phantom,
@@ -204,7 +204,7 @@ namespace corech
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
 void search(SearchEngineData<Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+            const DataFacade<Algorithm> &facade,
             SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             EdgeWeight &weight,
@@ -384,7 +384,7 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
 double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
-                          const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                          const DataFacade<Algorithm> &facade,
                           SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                           SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                           const PhantomNode &source_phantom,
diff --git a/src/engine/routing_algorithms/shortest_path.cpp b/src/engine/routing_algorithms/shortest_path.cpp
index a7a37e567..87cd75b63 100644
--- a/src/engine/routing_algorithms/shortest_path.cpp
+++ b/src/engine/routing_algorithms/shortest_path.cpp
@@ -22,7 +22,7 @@ const static constexpr bool DO_NOT_FORCE_LOOP = false;
 // searches source forward/reverse -> target forward/reverse
 template <typename Algorithm>
 void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
-                     const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                     const DataFacade<Algorithm> &facade,
                      typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                      typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                      const bool search_from_forward_node,
@@ -93,7 +93,7 @@ void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
 // source forward/reverse -> target reverse
 template <typename Algorithm>
 void search(SearchEngineData<Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+            const DataFacade<Algorithm> &facade,
             typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             const bool search_from_forward_node,
@@ -178,7 +178,7 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
 }
 
 template <typename Algorithm>
-void unpackLegs(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void unpackLegs(const DataFacade<Algorithm> &facade,
                 const std::vector<PhantomNodes> &phantom_nodes_vector,
                 const std::vector<NodeID> &total_packed_path,
                 const std::vector<std::size_t> &packed_leg_begin,
@@ -210,11 +210,10 @@ void unpackLegs(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
 }
 
 template <typename Algorithm>
-InternalRouteResult
-shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   const std::vector<PhantomNodes> &phantom_nodes_vector,
-                   const boost::optional<bool> continue_straight_at_waypoint)
+InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                       const DataFacade<Algorithm> &facade,
+                                       const std::vector<PhantomNodes> &phantom_nodes_vector,
+                                       const boost::optional<bool> continue_straight_at_waypoint)
 {
     InternalRouteResult raw_route_data;
     raw_route_data.segment_end_coordinates = phantom_nodes_vector;
@@ -459,19 +458,19 @@ shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
 
 template InternalRouteResult
 shortestPathSearch(SearchEngineData<ch::Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+                   const DataFacade<ch::Algorithm> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
                    const boost::optional<bool> continue_straight_at_waypoint);
 
 template InternalRouteResult
 shortestPathSearch(SearchEngineData<corech::Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+                   const DataFacade<corech::Algorithm> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
                    const boost::optional<bool> continue_straight_at_waypoint);
 
 template InternalRouteResult
 shortestPathSearch(SearchEngineData<mld::Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
+                   const DataFacade<mld::Algorithm> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
                    const boost::optional<bool> continue_straight_at_waypoint);
 
diff --git a/src/engine/routing_algorithms/tile_turns.cpp b/src/engine/routing_algorithms/tile_turns.cpp
index d49a9dad2..2af802be4 100644
--- a/src/engine/routing_algorithms/tile_turns.cpp
+++ b/src/engine/routing_algorithms/tile_turns.cpp
@@ -227,19 +227,15 @@ std::vector<TurnData> generateTurns(const datafacade &facade,
 } // namespace
 
 // CH Version of finding all turn penalties. Here is where the actual work is happening
-std::vector<TurnData>
-getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-             const std::vector<RTreeLeaf> &edges,
-             const std::vector<std::size_t> &sorted_edge_indexes)
+std::vector<TurnData> getTileTurns(const DataFacade<ch::Algorithm> &facade,
+                                   const std::vector<RTreeLeaf> &edges,
+                                   const std::vector<std::size_t> &sorted_edge_indexes)
 {
     // Define how to find the representative edge between two edge based nodes for a CH
     struct EdgeFinderCH
     {
-        EdgeFinderCH(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade)
-            : facade(facade)
-        {
-        }
-        const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade;
+        EdgeFinderCH(const DataFacade<ch::Algorithm> &facade) : facade(facade) {}
+        const DataFacade<ch::Algorithm> &facade;
 
         EdgeID operator()(const NodeID approach_node, const NodeID exit_node) const
         {
@@ -283,19 +279,15 @@ getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm>
 }
 
 // MLD version to find all turns
-std::vector<TurnData>
-getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-             const std::vector<RTreeLeaf> &edges,
-             const std::vector<std::size_t> &sorted_edge_indexes)
+std::vector<TurnData> getTileTurns(const DataFacade<mld::Algorithm> &facade,
+                                   const std::vector<RTreeLeaf> &edges,
+                                   const std::vector<std::size_t> &sorted_edge_indexes)
 {
     // Define how to find the representative edge between two edge-based-nodes for a MLD
     struct EdgeFinderMLD
     {
-        EdgeFinderMLD(const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade)
-            : facade(facade)
-        {
-        }
-        const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade;
+        EdgeFinderMLD(const DataFacade<mld::Algorithm> &facade) : facade(facade) {}
+        const DataFacade<mld::Algorithm> &facade;
 
         EdgeID operator()(const NodeID approach_node, const NodeID exit_node) const
         {