Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Refactor turn data into own class

Browse Source
This commit is contained in:
Patrick Niklaus
2017-04-02 01:00:03 +00:00
committed by Patrick Niklaus
parent 865111bca9
commit d7e1c9c09c
14 changed files with 293 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/extractor/files.hpp
+21
View File
@@ -65,6 +65,27 @@ inline void writeSegmentData(const boost::filesystem::path &path, const SegmentD
serialization::write(writer, segment_data);
}
// reads .osrm.edges
template<storage::Ownership Ownership>
inline void readTurnData(const boost::filesystem::path &path, detail::TurnDataContainerImpl<Ownership> &turn_data)
{
const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
storage::io::FileReader reader{path, fingerprint};
serialization::read(reader, turn_data);
}
// writes .osrm.edges
template<storage::Ownership Ownership>
inline void writeTurnData(const boost::filesystem::path &path, const detail::TurnDataContainerImpl<Ownership> &turn_data)
{
const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
storage::io::FileWriter writer{path, fingerprint};
serialization::write(writer, turn_data);
}
}
}
}
include/extractor/segment_data_container.hpp
+4 -4
View File
@@ -201,10 +201,10 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
friend void
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);
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
+35 -4
View File
@@ -4,6 +4,7 @@
#include "extractor/datasources.hpp"
#include "extractor/nbg_to_ebg.hpp"
#include "extractor/segment_data_container.hpp"
#include "extractor/turn_data_container.hpp"
#include "storage/io.hpp"
@@ -36,8 +37,9 @@ inline void write(storage::io::FileWriter &writer, Datasources &sources)
writer.WriteFrom(sources);
}
template <>
inline void read(storage::io::FileReader &reader, SegmentDataContainer &segment_data)
template <storage::Ownership Ownership>
inline void read(storage::io::FileReader &reader,
detail::SegmentDataContainerImpl<Ownership> &segment_data)
{
auto num_indices = reader.ReadElementCount32();
segment_data.index.resize(num_indices);
@@ -59,8 +61,9 @@ inline void read(storage::io::FileReader &reader, SegmentDataContainer &segment_
reader.ReadInto(segment_data.datasources);
}
template <>
inline void write(storage::io::FileWriter &writer, const SegmentDataContainer &segment_data)
template <storage::Ownership Ownership>
inline void write(storage::io::FileWriter &writer,
const detail::SegmentDataContainerImpl<Ownership> &segment_data)
{
writer.WriteElementCount32(segment_data.index.size());
writer.WriteFrom(segment_data.index);
@@ -78,6 +81,34 @@ inline void write(storage::io::FileWriter &writer, const SegmentDataContainer &s
writer.WriteFrom(segment_data.rev_durations);
writer.WriteFrom(segment_data.datasources);
}
template <storage::Ownership Ownership>
inline void read(storage::io::FileReader &reader,
detail::TurnDataContainerImpl<Ownership> &turn_data_container)
{
reader.DeserializeVector(turn_data_container.geometry_ids);
reader.DeserializeVector(turn_data_container.name_ids);
reader.DeserializeVector(turn_data_container.turn_instructions);
reader.DeserializeVector(turn_data_container.lane_data_ids);
reader.DeserializeVector(turn_data_container.travel_modes);
reader.DeserializeVector(turn_data_container.entry_class_ids);
reader.DeserializeVector(turn_data_container.pre_turn_bearings);
reader.DeserializeVector(turn_data_container.post_turn_bearings);
}
template <storage::Ownership Ownership>
inline void write(storage::io::FileWriter &writer,
const detail::TurnDataContainerImpl<Ownership> &turn_data_container)
{
writer.SerializeVector(turn_data_container.geometry_ids);
writer.SerializeVector(turn_data_container.name_ids);
writer.SerializeVector(turn_data_container.turn_instructions);
writer.SerializeVector(turn_data_container.lane_data_ids);
writer.SerializeVector(turn_data_container.travel_modes);
writer.SerializeVector(turn_data_container.entry_class_ids);
writer.SerializeVector(turn_data_container.pre_turn_bearings);
writer.SerializeVector(turn_data_container.post_turn_bearings);
}
}
}
}
include/extractor/turn_data_container.hpp
+134
View File
@@ -0,0 +1,134 @@
#ifndef OSRM_EXTRACTOR_TURN_DATA_CONTAINER_HPP
#define OSRM_EXTRACTOR_TURN_DATA_CONTAINER_HPP
#include "extractor/guidance/turn_instruction.hpp"
#include "extractor/travel_mode.hpp"
#include "storage/shared_memory_ownership.hpp"
#include "util/guidance/turn_bearing.hpp"
#include "util/shared_memory_vector_wrapper.hpp"
#include "util/typedefs.hpp"
namespace osrm
{
namespace storage
{
namespace io
{
class FileReader;
class FileWriter;
}
}
namespace extractor
{
namespace detail
{
template <storage::Ownership Ownership> class TurnDataContainerImpl;
}
namespace serialization
{
template <storage::Ownership Ownership>
void read(storage::io::FileReader &reader, detail::TurnDataContainerImpl<Ownership> &turn_data);
template <storage::Ownership Ownership>
void write(storage::io::FileWriter &writer,
const detail::TurnDataContainerImpl<Ownership> &turn_data);
}
namespace detail
{
template <storage::Ownership Ownership> class TurnDataContainerImpl
{
template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;
public:
TurnDataContainerImpl() = default;
TurnDataContainerImpl(Vector<GeometryID> geometry_ids_,
Vector<NameID> name_ids_,
Vector<extractor::guidance::TurnInstruction> turn_instructions_,
Vector<LaneDataID> lane_data_ids_,
Vector<extractor::TravelMode> travel_modes_,
Vector<EntryClassID> entry_class_ids_,
Vector<util::guidance::TurnBearing> pre_turn_bearings_,
Vector<util::guidance::TurnBearing> post_turn_bearings_)
: geometry_ids(std::move(geometry_ids_)), name_ids(std::move(name_ids_)),
turn_instructions(std::move(turn_instructions_)),
lane_data_ids(std::move(lane_data_ids_)), travel_modes(std::move(travel_modes_)),
entry_class_ids(std::move(entry_class_ids_)),
pre_turn_bearings(std::move(pre_turn_bearings_)),
post_turn_bearings(std::move(post_turn_bearings_))
{
}
GeometryID GetGeometryID(const EdgeID id) const { return geometry_ids[id]; }
EntryClassID GetEntryClassID(const EdgeID id) const { return entry_class_ids[id]; }
util::guidance::TurnBearing GetPreTurnBearing(const EdgeID id) const
{
return pre_turn_bearings[id];
}
util::guidance::TurnBearing GetPostTurnBearing(const EdgeID id) const
{
return post_turn_bearings[id];
}
bool HasLaneData(const EdgeID id) const { return INVALID_LANE_DATAID != lane_data_ids[id]; }
NameID GetNameID(const EdgeID id) const { return name_ids[id]; }
extractor::guidance::TurnInstruction GetTurnInstruction(const EdgeID id) const
{
return turn_instructions[id];
}
// Used by EdgeBasedGraphFactory to fill data structure
template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
void push_back(GeometryID geometry_id,
NameID name_id,
extractor::guidance::TurnInstruction turn_instruction,
LaneDataID lane_data_id,
EntryClassID entry_class_id,
extractor::TravelMode travel_mode,
util::guidance::TurnBearing pre_turn_bearing,
util::guidance::TurnBearing post_turn_bearing)
{
geometry_ids.push_back(geometry_id);
name_ids.push_back(name_id);
turn_instructions.push_back(turn_instruction);
lane_data_ids.push_back(lane_data_id);
travel_modes.push_back(travel_mode);
entry_class_ids.push_back(entry_class_id);
pre_turn_bearings.push_back(pre_turn_bearing);
post_turn_bearings.push_back(post_turn_bearing);
}
friend void serialization::read<Ownership>(storage::io::FileReader &reader,
TurnDataContainerImpl &turn_data_container);
friend void serialization::write<Ownership>(storage::io::FileWriter &writer,
const TurnDataContainerImpl &turn_data_container);
private:
Vector<GeometryID> geometry_ids;
Vector<NameID> name_ids;
Vector<extractor::guidance::TurnInstruction> turn_instructions;
Vector<LaneDataID> lane_data_ids;
Vector<extractor::TravelMode> travel_modes;
Vector<EntryClassID> entry_class_ids;
Vector<util::guidance::TurnBearing> pre_turn_bearings;
Vector<util::guidance::TurnBearing> post_turn_bearings;
};
}
using TurnDataContainer = detail::TurnDataContainerImpl<storage::Ownership::Container>;
using TurnDataView = detail::TurnDataContainerImpl<storage::Ownership::View>;
}
}
#endif