Separate serialization and files in extractor

include/extractor/files.hpp

@@ -0,0 +1,72 @@
+#ifndef OSRM_EXTRACTOR_FILES_HPP
+#define OSRM_EXTRACTOR_FILES_HPP
+
+#include "extractor/seralization.hpp"
+
+#include <boost/assert.hpp>
+
+namespace osrm
+{
+namespace extractor
+{
+namespace files
+{
+
+// reads .osrm.cnbg_to_ebg
+inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGToEBG> &mapping)
+{
+    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    serialization::read(reader, mapping);
+}
+
+// writes .osrm.cnbg_to_ebg
+inline void writeNBGMapping(const boost::filesystem::path &path, const std::vector<NBGToEBG> &mapping)
+{
+    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    serialization::write(writer, mapping);
+}
+
+// reads .osrm.datasource_names
+inline void readDatasources(const boost::filesystem::path &path, Datasources &sources)
+{
+    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    serialization::read(reader, sources);
+}
+
+// writes .osrm.datasource_names
+inline void writeDatasources(const boost::filesystem::path &path, Datasources &sources)
+{
+    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    serialization::write(writer, sources);
+}
+
+// reads .osrm.geometry
+inline void readSegmentData(const boost::filesystem::path &path, SegmentDataContainer &segment_data)
+{
+    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    serialization::read(reader, segment_data);
+}
+
+// writes .osrm.geometry
+inline void writeSegmentData(const boost::filesystem::path &path, const SegmentDataContainer &segment_data)
+{
+    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    serialization::write(writer, segment_data);
+}
+}
+}
+}
+
+#endif

include/extractor/segment_data_container.hpp

@@ -17,6 +17,15 @@
 
 namespace osrm
 {
+namespace storage
+{
+namespace io
+{
+class FileReader;
+class FileWriter;
+}
+}
+
 namespace extractor
 {
 
@@ -27,13 +36,13 @@ namespace detail
 template <storage::Ownership Ownership> class SegmentDataContainerImpl;
 }
 
-namespace io
+namespace serialization
 {
 template <storage::Ownership Ownership>
-inline void read(const boost::filesystem::path &path,
+inline void read(storage::io::FileReader &reader,
                  detail::SegmentDataContainerImpl<Ownership> &segment_data);
 template <storage::Ownership Ownership>
-inline void write(const boost::filesystem::path &path,
+inline void write(storage::io::FileWriter &writer,
                   const detail::SegmentDataContainerImpl<Ownership> &segment_data);
 }
 
@@ -190,11 +199,12 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
     auto GetNumberOfGeometries() const { return index.size() - 1; }
     auto GetNumberOfSegments() const { return fwd_weights.size(); }
 
-    friend void io::read<Ownership>(const boost::filesystem::path &path,
-                                    detail::SegmentDataContainerImpl<Ownership> &segment_data);
     friend void
-    io::write<Ownership>(const boost::filesystem::path &path,
-                         const detail::SegmentDataContainerImpl<Ownership> &segment_data);
+    serialization::read<Ownership>(storage::io::FileReader &reader,
+                             detail::SegmentDataContainerImpl<Ownership> &segment_data);
+    friend void
+    serialization::write<Ownership>(storage::io::FileWriter &writer,
+                              const detail::SegmentDataContainerImpl<Ownership> &segment_data);
 
   private:
     Vector<std::uint32_t> index;

include/extractor/seralization.hpp

@@ -13,47 +13,32 @@ namespace osrm
 {
 namespace extractor
 {
-namespace io
+namespace serialization
 {
 
-inline void read(const boost::filesystem::path &path, std::vector<NBGToEBG> &mapping)
+inline void read(storage::io::FileReader &reader, std::vector<NBGToEBG> &mapping)
 {
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
     reader.DeserializeVector(mapping);
 }
 
-inline void write(const boost::filesystem::path &path, const std::vector<NBGToEBG> &mapping)
+inline void write(storage::io::FileWriter &writer, const std::vector<NBGToEBG> &mapping)
 {
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter reader{path, fingerprint};
-
-    reader.SerializeVector(mapping);
+    writer.SerializeVector(mapping);
 }
 
-inline void read(const boost::filesystem::path &path, Datasources &sources)
+inline void read(storage::io::FileReader &reader, Datasources &sources)
 {
-    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
     reader.ReadInto(sources);
 }
 
-inline void write(const boost::filesystem::path &path, Datasources &sources)
+inline void write(storage::io::FileWriter &writer, Datasources &sources)
 {
-    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
     writer.WriteFrom(sources);
 }
 
 template <>
-inline void read(const boost::filesystem::path &path, SegmentDataContainer &segment_data)
+inline void read(storage::io::FileReader &reader, SegmentDataContainer &segment_data)
 {
-    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
     auto num_indices = reader.ReadElementCount32();
     segment_data.index.resize(num_indices);
     reader.ReadInto(segment_data.index.data(), num_indices);
@@ -75,11 +60,8 @@ inline void read(const boost::filesystem::path &path, SegmentDataContainer &segm
 }
 
 template <>
-inline void write(const boost::filesystem::path &path, const SegmentDataContainer &segment_data)
+inline void write(storage::io::FileWriter &writer, const SegmentDataContainer &segment_data)
 {
-    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
     writer.WriteElementCount32(segment_data.index.size());
     writer.WriteFrom(segment_data.index);