Refactor turn description into own file

include/extractor/files.hpp

@@ -1,6 +1,7 @@
 #ifndef OSRM_EXTRACTOR_FILES_HPP
 #define OSRM_EXTRACTOR_FILES_HPP
 
+#include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/seralization.hpp"
 
 #include <boost/assert.hpp>
@@ -92,6 +93,33 @@ inline void writeTurnData(const boost::filesystem::path &path,
 
     serialization::write(writer, turn_data);
 }
+
+// reads .osrm.tls
+template <bool UseShareMemory>
+inline void readTurnLaneDescriptions(const boost::filesystem::path &path,
+                         typename util::ShM<std::uint32_t, UseShareMemory>::vector &turn_offsets,
+                         typename util::ShM<extractor::guidance::TurnLaneType::Mask, UseShareMemory>::vector &turn_masks)
+{
+    const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    reader.DeserializeVector(turn_offsets);
+    reader.DeserializeVector(turn_masks);
+}
+
+// writes .osrm.tls
+template <bool UseShareMemory>
+inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
+                         const typename util::ShM<std::uint32_t, UseShareMemory>::vector &turn_offsets,
+                         const typename util::ShM<extractor::guidance::TurnLaneType::Mask, UseShareMemory>::vector &turn_masks)
+{
+    const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    writer.SerializeVector(turn_offsets);
+    writer.SerializeVector(turn_masks);
+}
+
 }
 }
 }

include/util/io.hpp

@@ -1,46 +0,0 @@
-#ifndef OSRM_INCLUDE_UTIL_IO_HPP_
-#define OSRM_INCLUDE_UTIL_IO_HPP_
-
-#include "util/log.hpp"
-
-#include <boost/filesystem.hpp>
-#include <boost/numeric/conversion/cast.hpp>
-
-#include <cstddef>
-#include <cstdint>
-
-#include <bitset>
-#include <fstream>
-#include <stxxl/vector>
-#include <vector>
-
-#include "storage/io.hpp"
-#include "util/fingerprint.hpp"
-
-namespace osrm
-{
-namespace util
-{
-
-template <typename simple_type>
-void deserializeAdjacencyArray(const std::string &filename,
-                               std::vector<std::uint32_t> &offsets,
-                               std::vector<simple_type> &data)
-{
-    storage::io::FileReader file(filename, storage::io::FileReader::HasNoFingerprint);
-
-    file.DeserializeVector(offsets);
-    file.DeserializeVector(data);
-
-    // offsets have to match up with the size of the data
-    if (offsets.empty() || (offsets.back() != boost::numeric_cast<std::uint32_t>(data.size())))
-        throw util::exception(
-            "Error in " + filename +
-            (offsets.empty() ? "Offsets are empty" : "Offset and data size do not match") +
-            SOURCE_REF);
-}
-
-} // namespace util
-} // namespace osrm
-
-#endif // OSRM_INCLUDE_UTIL_IO_HPP_

src/contractor/contractor.cpp

@@ -15,7 +15,6 @@
 #include "util/exception_utils.hpp"
 #include "util/graph_loader.hpp"
 #include "util/integer_range.hpp"
-#include "util/io.hpp"
 #include "util/log.hpp"
 #include "util/static_graph.hpp"
 #include "util/string_util.hpp"

src/extractor/extraction_containers.cpp

@@ -7,7 +7,6 @@
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
 #include "util/fingerprint.hpp"
-#include "util/io.hpp"
 #include "util/log.hpp"
 #include "util/name_table.hpp"
 #include "util/timing_util.hpp"

src/extractor/extractor.cpp

@@ -11,11 +11,11 @@
 #include "extractor/scripting_environment.hpp"
 
 #include "storage/io.hpp"
+
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
 #include "util/graph_loader.hpp"
 #include "util/integer_range.hpp"
-#include "util/io.hpp"
 #include "util/log.hpp"
 #include "util/name_table.hpp"
 #include "util/range_table.hpp"

src/storage/storage.cpp

@@ -24,7 +24,6 @@
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
 #include "util/fingerprint.hpp"
-#include "util/io.hpp"
 #include "util/log.hpp"
 #include "util/packed_vector.hpp"
 #include "util/range_table.hpp"
@@ -213,15 +212,14 @@ void Storage::PopulateLayout(DataLayout &layout)
     }
 
     {
-        std::vector<std::uint32_t> lane_description_offsets;
+        io::FileReader reader(config.turn_lane_description_path, io::FileReader::HasNoFingerprint);
-        std::vector<extractor::guidance::TurnLaneType::Mask> lane_description_masks;
+        auto num_offsets = reader.ReadVectorSize<std::uint32_t>();
-        util::deserializeAdjacencyArray(config.turn_lane_description_path.string(),
+        auto num_masks = reader.ReadVectorSize<extractor::guidance::TurnLaneType::Mask>();
-                                        lane_description_offsets,
+
-                                        lane_description_masks);
         layout.SetBlockSize<std::uint32_t>(DataLayout::LANE_DESCRIPTION_OFFSETS,
-                                           lane_description_offsets.size());
+                                           num_offsets);
         layout.SetBlockSize<extractor::guidance::TurnLaneType::Mask>(
-            DataLayout::LANE_DESCRIPTION_MASKS, lane_description_masks.size());
+            DataLayout::LANE_DESCRIPTION_MASKS, num_masks);
     }
 
     // Loading information for original edges
@@ -558,38 +556,17 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
 
     // Turn lane descriptions
     {
-        std::vector<std::uint32_t> lane_description_offsets;
+        auto offsets_ptr = layout.GetBlockPtr<std::uint32_t, true>(
-        std::vector<extractor::guidance::TurnLaneType::Mask> lane_description_masks;
+            memory_ptr, storage::DataLayout::LANE_DESCRIPTION_OFFSETS);
-        util::deserializeAdjacencyArray(config.turn_lane_description_path.string(),
+        util::ShM<std::uint32_t, true>::vector offsets(
-                                        lane_description_offsets,
+            offsets_ptr, layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_OFFSETS]);
-                                        lane_description_masks);
 
-        const auto turn_lane_offset_ptr = layout.GetBlockPtr<std::uint32_t, true>(
+        auto masks_ptr = layout.GetBlockPtr<extractor::guidance::TurnLaneType::Mask, true>(
-            memory_ptr, DataLayout::LANE_DESCRIPTION_OFFSETS);
+            memory_ptr, storage::DataLayout::LANE_DESCRIPTION_MASKS);
-        if (!lane_description_offsets.empty())
+        util::vector_view<extractor::guidance::TurnLaneType::Mask> masks(
-        {
+            masks_ptr, layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_MASKS]);
-            BOOST_ASSERT(
-                static_cast<std::size_t>(
-                    layout.GetBlockSize(DataLayout::LANE_DESCRIPTION_OFFSETS)) >=
-                std::distance(lane_description_offsets.begin(), lane_description_offsets.end()) *
-                    sizeof(decltype(lane_description_offsets)::value_type));
-            std::copy(lane_description_offsets.begin(),
-                      lane_description_offsets.end(),
-                      turn_lane_offset_ptr);
-        }
 
-        const auto turn_lane_mask_ptr =
+        extractor::files::readTurnLaneDescriptions<true>(config.turn_lane_description_path, offsets, masks);
-            layout.GetBlockPtr<extractor::guidance::TurnLaneType::Mask, true>(
-                memory_ptr, DataLayout::LANE_DESCRIPTION_MASKS);
-        if (!lane_description_masks.empty())
-        {
-            BOOST_ASSERT(
-                static_cast<std::size_t>(layout.GetBlockSize(DataLayout::LANE_DESCRIPTION_MASKS)) >=
-                std::distance(lane_description_masks.begin(), lane_description_masks.end()) *
-                    sizeof(decltype(lane_description_masks)::value_type));
-            std::copy(
-                lane_description_masks.begin(), lane_description_masks.end(), turn_lane_mask_ptr);
-        }
     }
 
     // Load original edge data

src/updater/updater.cpp

@@ -15,7 +15,6 @@
 #include "util/for_each_pair.hpp"
 #include "util/graph_loader.hpp"
 #include "util/integer_range.hpp"
-#include "util/io.hpp"
 #include "util/log.hpp"
 #include "util/static_graph.hpp"
 #include "util/static_rtree.hpp"