1 #ifndef OSRM_GUIDANCE_TURN_DATA_CONTAINER_HPP
2 #define OSRM_GUIDANCE_TURN_DATA_CONTAINER_HPP
3 
4 #include "extractor/travel_mode.hpp"
5 #include "guidance/turn_bearing.hpp"
6 #include "guidance/turn_instruction.hpp"
7 
8 #include "storage/shared_memory_ownership.hpp"
9 #include "storage/tar_fwd.hpp"
10 
11 #include "util/vector_view.hpp"
12 
13 #include "util/typedefs.hpp"
14 
15 namespace osrm
16 {
17 namespace guidance
18 {
19 namespace detail
20 {
21 template <storage::Ownership Ownership> class TurnDataContainerImpl;
22 }
23 
24 namespace serialization
25 {
26 template <storage::Ownership Ownership>
27 void read(storage::tar::FileReader &reader,
28           const std::string &name,
29           detail::TurnDataContainerImpl<Ownership> &turn_data);
30 
31 template <storage::Ownership Ownership>
32 void write(storage::tar::FileWriter &writer,
33            const std::string &name,
34            const detail::TurnDataContainerImpl<Ownership> &turn_data);
35 } // namespace serialization
36 
37 struct TurnData
38 {
39     TurnInstruction turn_instruction;
40     LaneDataID lane_data_id;
41     EntryClassID entry_class_id;
42     TurnBearing pre_turn_bearing;
43     TurnBearing post_turn_bearing;
44 };
45 
46 namespace detail
47 {
48 template <storage::Ownership Ownership> class TurnDataContainerImpl
49 {
50     template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
51 
52   public:
53     TurnDataContainerImpl() = default;
54 
TurnDataContainerImpl(Vector<TurnInstruction> turn_instructions,Vector<LaneDataID> lane_data_ids,Vector<EntryClassID> entry_class_ids,Vector<TurnBearing> pre_turn_bearings,Vector<TurnBearing> post_turn_bearings)55     TurnDataContainerImpl(Vector<TurnInstruction> turn_instructions,
56                           Vector<LaneDataID> lane_data_ids,
57                           Vector<EntryClassID> entry_class_ids,
58                           Vector<TurnBearing> pre_turn_bearings,
59                           Vector<TurnBearing> post_turn_bearings)
60         : turn_instructions(std::move(turn_instructions)), lane_data_ids(std::move(lane_data_ids)),
61           entry_class_ids(std::move(entry_class_ids)),
62           pre_turn_bearings(std::move(pre_turn_bearings)),
63           post_turn_bearings(std::move(post_turn_bearings))
64     {
65     }
66 
GetEntryClassID(const EdgeID id) const67     EntryClassID GetEntryClassID(const EdgeID id) const { return entry_class_ids[id]; }
68 
GetPreTurnBearing(const EdgeID id) const69     TurnBearing GetPreTurnBearing(const EdgeID id) const { return pre_turn_bearings[id]; }
70 
GetPostTurnBearing(const EdgeID id) const71     TurnBearing GetPostTurnBearing(const EdgeID id) const { return post_turn_bearings[id]; }
72 
GetLaneDataID(const EdgeID id) const73     LaneDataID GetLaneDataID(const EdgeID id) const { return lane_data_ids[id]; }
74 
HasLaneData(const EdgeID id) const75     bool HasLaneData(const EdgeID id) const { return INVALID_LANE_DATAID != lane_data_ids[id]; }
76 
GetTurnInstruction(const EdgeID id) const77     guidance::TurnInstruction GetTurnInstruction(const EdgeID id) const
78     {
79         return turn_instructions[id];
80     }
81 
82     // Used by EdgeBasedGraphFactory to fill data structure
83     template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
push_back(const TurnData & data)84     void push_back(const TurnData &data)
85     {
86         turn_instructions.push_back(data.turn_instruction);
87         lane_data_ids.push_back(data.lane_data_id);
88         entry_class_ids.push_back(data.entry_class_id);
89         pre_turn_bearings.push_back(data.pre_turn_bearing);
90         post_turn_bearings.push_back(data.post_turn_bearing);
91     }
92 
93     template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
append(const std::vector<TurnData> & others)94     void append(const std::vector<TurnData> &others)
95     {
96         std::for_each(
97             others.begin(), others.end(), [this](const TurnData &other) { push_back(other); });
98     }
99 
100     friend void serialization::read<Ownership>(storage::tar::FileReader &reader,
101                                                const std::string &name,
102                                                TurnDataContainerImpl &turn_data_container);
103     friend void serialization::write<Ownership>(storage::tar::FileWriter &writer,
104                                                 const std::string &name,
105                                                 const TurnDataContainerImpl &turn_data_container);
106 
107   private:
108     Vector<TurnInstruction> turn_instructions;
109     Vector<LaneDataID> lane_data_ids;
110     Vector<EntryClassID> entry_class_ids;
111     Vector<TurnBearing> pre_turn_bearings;
112     Vector<TurnBearing> post_turn_bearings;
113 };
114 } // namespace detail
115 
116 using TurnDataExternalContainer = detail::TurnDataContainerImpl<storage::Ownership::External>;
117 using TurnDataContainer = detail::TurnDataContainerImpl<storage::Ownership::Container>;
118 using TurnDataView = detail::TurnDataContainerImpl<storage::Ownership::View>;
119 } // namespace guidance
120 } // namespace osrm
121 
122 #endif
123