1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
#pragma once
#include "routing/cross_mwm_connector.hpp"
#include "routing/cross_mwm_connector_serialization.hpp"
#include "routing/fake_feature_ids.hpp"
#include "routing/routing_exceptions.hpp"
#include "routing/segment.hpp"
#include "routing/transition_points.hpp"
#include "routing/vehicle_mask.hpp"
#include "routing_common/num_mwm_id.hpp"
#include "routing_common/vehicle_model.hpp"
#include "coding/file_container.hpp"
#include "coding/reader.hpp"
#include "indexer/data_source.hpp"
#include <map>
#include <memory>
#include <vector>
namespace routing
{
namespace connector
{
template <typename CrossMwmId>
inline FilesContainerR::TReader GetReader(FilesContainerR const & cont)
{
return cont.GetReader(CROSS_MWM_FILE_TAG);
}
template <>
inline FilesContainerR::TReader GetReader<TransitId>(FilesContainerR const & cont)
{
return cont.GetReader(TRANSIT_CROSS_MWM_FILE_TAG);
}
template <typename CrossMwmId>
uint32_t constexpr GetFeaturesOffset() noexcept
{
return 0;
}
template <>
uint32_t constexpr GetFeaturesOffset<TransitId>() noexcept
{
return FakeFeatureIds::kTransitGraphFeaturesStart;
}
template <typename CrossMwmId>
void AssertConnectorIsFound(NumMwmId neighbor, bool isConnectorFound)
{
CHECK(isConnectorFound, ("Connector for mwm with number mwm id", neighbor, "was not deserialized."));
}
template <>
inline void AssertConnectorIsFound<TransitId>(NumMwmId /* neighbor */, bool /* isConnectorFound */)
{
}
} // namespace connector
template <typename CrossMwmId>
class CrossMwmIndexGraph final
{
public:
using ReaderSourceFile = ReaderSource<FilesContainerR::TReader>;
CrossMwmIndexGraph(DataSourceBase & dataSource, std::shared_ptr<NumMwmIds> numMwmIds, VehicleType vehicleType)
: m_dataSource(dataSource), m_numMwmIds(numMwmIds), m_vehicleType(vehicleType)
{
}
bool IsTransition(Segment const & s, bool isOutgoing)
{
CrossMwmConnector<CrossMwmId> const & c = GetCrossMwmConnectorWithTransitions(s.GetMwmId());
return c.IsTransition(s, isOutgoing);
}
/// \brief Fills |twins| based on transitions defined in cross_mwm section.
/// \note In cross_mwm section transitions are defined by osm ids of theirs features.
/// \note This method fills |twins| with all available twins iff all neighboring of mwm of |s|
// have cross_mwm section.
void GetTwinsByCrossMwmId(Segment const & s, bool isOutgoing, std::vector<NumMwmId> const & neighbors,
std::vector<Segment> & twins)
{
auto const & crossMwmId = GetCrossMwmConnectorWithTransitions(s.GetMwmId()).GetCrossMwmId(s);
for (NumMwmId const neighbor : neighbors)
{
auto const it = m_connectors.find(neighbor);
// In case of TransitId, a connector for a mwm with number id |neighbor| may not be found
// if mwm with such id does not contain corresponding transit_cross_mwm section.
// It may happen in case of obsolete mwms.
// Note. Actually it is assumed that connectors always must be found for car routing case.
// That means mwm without cross_mwm section is not supported.
connector::AssertConnectorIsFound<CrossMwmId>(neighbor, it != m_connectors.cend());
if (it == m_connectors.cend())
continue;
CrossMwmConnector<CrossMwmId> const & connector = it->second;
// Note. Last parameter in the method below (isEnter) should be set to |isOutgoing|.
// If |isOutgoing| == true |s| should be an exit transition segment and the method below searches enters
// and the last parameter (|isEnter|) should be set to true.
// If |isOutgoing| == false |s| should be an enter transition segment and the method below searches exits
// and the last parameter (|isEnter|) should be set to false.
Segment const * twinSeg = connector.GetTransition(crossMwmId, s.GetSegmentIdx(), isOutgoing);
if (twinSeg == nullptr)
continue;
CHECK_NOT_EQUAL(twinSeg->GetMwmId(), s.GetMwmId(), ());
twins.push_back(*twinSeg);
}
}
void GetOutgoingEdgeList(Segment const & s, std::vector<SegmentEdge> & edges)
{
CrossMwmConnector<CrossMwmId> const & c = GetCrossMwmConnectorWithWeights(s.GetMwmId());
c.GetOutgoingEdgeList(s, edges);
}
void Clear() { m_connectors.clear(); }
TransitionPoints GetTransitionPoints(Segment const & s, bool isOutgoing)
{
auto const & connector = GetCrossMwmConnectorWithTransitions(s.GetMwmId());
// In case of transition segments of index graph cross-mwm section the front point of segment
// is used as a point which corresponds to the segment.
return TransitionPoints({connector.GetPoint(s, true /* front */)});
}
bool InCache(NumMwmId numMwmId) const { return m_connectors.count(numMwmId) != 0; }
CrossMwmConnector<CrossMwmId> const & GetCrossMwmConnectorWithTransitions(NumMwmId numMwmId)
{
auto const it = m_connectors.find(numMwmId);
if (it != m_connectors.cend())
return it->second;
return Deserialize(
numMwmId,
CrossMwmConnectorSerializer::DeserializeTransitions<ReaderSourceFile, CrossMwmId>);
}
void LoadCrossMwmConnectorWithTransitions(NumMwmId numMwmId)
{
GetCrossMwmConnectorWithTransitions(numMwmId);
}
std::vector<Segment> const & GetTransitions(NumMwmId numMwmId, bool isEnter)
{
auto const & connector = GetCrossMwmConnectorWithTransitions(numMwmId);
return isEnter ? connector.GetEnters() : connector.GetExits();
}
private:
CrossMwmConnector<CrossMwmId> const & GetCrossMwmConnectorWithWeights(NumMwmId numMwmId)
{
auto const & c = GetCrossMwmConnectorWithTransitions(numMwmId);
if (c.WeightsWereLoaded())
return c;
return Deserialize(
numMwmId, CrossMwmConnectorSerializer::DeserializeWeights<ReaderSourceFile, CrossMwmId>);
}
/// \brief Deserializes connectors for an mwm with |numMwmId|.
/// \param fn is a function implementing deserialization.
/// \note Each CrossMwmConnector contained in |m_connectors| may be deserizalize in two stages.
/// The first one is transition deserialization and the second is weight deserialization.
/// Transition deserialization is much faster and used more often.
template <typename Fn>
CrossMwmConnector<CrossMwmId> const & Deserialize(NumMwmId numMwmId, Fn && fn)
{
MwmSet::MwmHandle handle = m_dataSource.GetMwmHandleByCountryFile(m_numMwmIds->GetFile(numMwmId));
if (!handle.IsAlive())
MYTHROW(RoutingException, ("Mwm", m_numMwmIds->GetFile(numMwmId), "cannot be loaded."));
MwmValue * value = handle.GetValue<MwmValue>();
CHECK(value != nullptr, ("Country file:", m_numMwmIds->GetFile(numMwmId)));
FilesContainerR::TReader const reader =
FilesContainerR::TReader(connector::GetReader<CrossMwmId>(value->m_cont));
ReaderSourceFile src(reader);
auto it = m_connectors.find(numMwmId);
if (it == m_connectors.end())
it = m_connectors
.emplace(numMwmId, CrossMwmConnector<CrossMwmId>(
numMwmId, connector::GetFeaturesOffset<CrossMwmId>()))
.first;
fn(m_vehicleType, it->second, src);
return it->second;
}
DataSourceBase & m_dataSource;
std::shared_ptr<NumMwmIds> m_numMwmIds;
VehicleType m_vehicleType;
/// \note |m_connectors| contains cache with transition segments and leap edges.
/// Each mwm in |m_connectors| may be in two conditions:
/// * with loaded transition segments (after a call to
/// CrossMwmConnectorSerializer::DeserializeTransitions())
/// * with loaded transition segments and with loaded weights
/// (after a call to CrossMwmConnectorSerializer::DeserializeTransitions()
/// and CrossMwmConnectorSerializer::DeserializeWeights())
std::map<NumMwmId, CrossMwmConnector<CrossMwmId>> m_connectors;
};
} // namespace routing
|
