No shared_memory_wrapper, (De)SerializeVector

include/partition/cell_storage.hpp

@@ -6,7 +6,7 @@
 #include "util/assert.hpp"
 #include "util/for_each_range.hpp"
 #include "util/log.hpp"
-#include "util/shared_memory_vector_wrapper.hpp"
+#include "util/vector_view.hpp"
 #include "util/typedefs.hpp"
 
 #include "storage/io.hpp"
@@ -74,7 +74,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
     };
 
   private:
-    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;
+    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
 
     // Implementation of the cell view. We need a template parameter here
     // because we need to derive a read-only and read-write view from this.

include/partition/multi_level_graph.hpp

@@ -6,6 +6,7 @@
 #include "storage/shared_memory_ownership.hpp"
 
 #include "util/static_graph.hpp"
+#include "util/vector_view.hpp"
 
 #include <tbb/parallel_sort.h>
 
@@ -41,7 +42,7 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
 {
   private:
     using SuperT = util::StaticGraph<EdgeDataT, Ownership>;
-    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;
+    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
 
   public:
     // We limit each node to have 255 edges

include/partition/multi_level_partition.hpp

@@ -4,7 +4,7 @@
 #include "util/exception.hpp"
 #include "util/for_each_pair.hpp"
 #include "util/msb.hpp"
-#include "util/shared_memory_vector_wrapper.hpp"
+#include "util/vector_view.hpp"
 #include "util/typedefs.hpp"
 
 #include "storage/io.hpp"
@@ -56,7 +56,7 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
     static const constexpr std::uint8_t MAX_NUM_LEVEL = 16;
     static const constexpr std::uint8_t NUM_PARTITION_BITS = sizeof(PartitionID) * CHAR_BIT;
 
-    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;
+    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
 
   public:
     // Contains all data necessary to describe the level hierarchy

include/partition/serialization.hpp

@@ -7,6 +7,7 @@
 #include "partition/multi_level_partition.hpp"
 
 #include "storage/io.hpp"
+#include "storage/serialization.hpp"
 #include "storage/shared_memory_ownership.hpp"
 
 namespace osrm
@@ -19,26 +20,26 @@ namespace serialization
 template <typename EdgeDataT, storage::Ownership Ownership>
 inline void read(storage::io::FileReader &reader, MultiLevelGraph<EdgeDataT, Ownership> &graph)
 {
-    reader.DeserializeVector(graph.node_array);
-    reader.DeserializeVector(graph.edge_array);
-    reader.DeserializeVector(graph.node_to_edge_offset);
+    storage::serialization::read(reader, graph.node_array);
+    storage::serialization::read(reader, graph.edge_array);
+    storage::serialization::read(reader, graph.node_to_edge_offset);
 }
 
 template <typename EdgeDataT, storage::Ownership Ownership>
 inline void write(storage::io::FileWriter &writer,
                   const MultiLevelGraph<EdgeDataT, Ownership> &graph)
 {
-    writer.SerializeVector(graph.node_array);
-    writer.SerializeVector(graph.edge_array);
-    writer.SerializeVector(graph.node_to_edge_offset);
+    storage::serialization::write(writer, graph.node_array);
+    storage::serialization::write(writer, graph.edge_array);
+    storage::serialization::write(writer, graph.node_to_edge_offset);
 }
 
 template <storage::Ownership Ownership>
 inline void read(storage::io::FileReader &reader, detail::MultiLevelPartitionImpl<Ownership> &mlp)
 {
     reader.ReadInto(*mlp.level_data);
-    reader.DeserializeVector(mlp.partition);
-    reader.DeserializeVector(mlp.cell_to_children);
+    storage::serialization::read(reader, mlp.partition);
+    storage::serialization::read(reader, mlp.cell_to_children);
 }
 
 template <storage::Ownership Ownership>
@@ -46,29 +47,29 @@ inline void write(storage::io::FileWriter &writer,
                   const detail::MultiLevelPartitionImpl<Ownership> &mlp)
 {
     writer.WriteOne(*mlp.level_data);
-    writer.SerializeVector(mlp.partition);
-    writer.SerializeVector(mlp.cell_to_children);
+    storage::serialization::write(writer, mlp.partition);
+    storage::serialization::write(writer, mlp.cell_to_children);
 }
 
 template <storage::Ownership Ownership>
 inline void read(storage::io::FileReader &reader, detail::CellStorageImpl<Ownership> &storage)
 {
-    reader.DeserializeVector(storage.weights);
-    reader.DeserializeVector(storage.source_boundary);
-    reader.DeserializeVector(storage.destination_boundary);
-    reader.DeserializeVector(storage.cells);
-    reader.DeserializeVector(storage.level_to_cell_offset);
+    storage::serialization::read(reader, storage.weights);
+    storage::serialization::read(reader, storage.source_boundary);
+    storage::serialization::read(reader, storage.destination_boundary);
+    storage::serialization::read(reader, storage.cells);
+    storage::serialization::read(reader, storage.level_to_cell_offset);
 }
 
 template <storage::Ownership Ownership>
 inline void write(storage::io::FileWriter &writer,
                   const detail::CellStorageImpl<Ownership> &storage)
 {
-    writer.SerializeVector(storage.weights);
-    writer.SerializeVector(storage.source_boundary);
-    writer.SerializeVector(storage.destination_boundary);
-    writer.SerializeVector(storage.cells);
-    writer.SerializeVector(storage.level_to_cell_offset);
+    storage::serialization::write(writer, storage.weights);
+    storage::serialization::write(writer, storage.source_boundary);
+    storage::serialization::write(writer, storage.destination_boundary);
+    storage::serialization::write(writer, storage.cells);
+    storage::serialization::write(writer, storage.level_to_cell_offset);
 }
 }
 }