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
|
#pragma once
#include "track_analyzing/track.hpp"
#include "routing/segment.hpp"
#include "routing_common/num_mwm_id.hpp"
#include "platform/country_file.hpp"
#include "coding/read_write_utils.hpp"
#include "coding/reader.hpp"
#include "coding/traffic.hpp"
#include "coding/varint.hpp"
#include "coding/write_to_sink.hpp"
#include "coding/writer.hpp"
#include "base/assert.hpp"
#include "base/checked_cast.hpp"
#include <cstdint>
#include <memory>
#include <vector>
namespace track_analyzing
{
class MwmToMatchedTracksSerializer final
{
public:
MwmToMatchedTracksSerializer(std::shared_ptr<routing::NumMwmIds> numMwmIds)
: m_numMwmIds(move(numMwmIds))
{
}
template <class Sink>
void Serialize(MwmToMatchedTracks const & mwmToMatchedTracks, Sink & sink)
{
WriteSize(sink, mwmToMatchedTracks.size());
for (auto const & mwmIt : mwmToMatchedTracks)
{
rw::Write(sink, m_numMwmIds->GetFile(mwmIt.first).GetName());
UserToMatchedTracks const & userToMatchedTracks = mwmIt.second;
CHECK(!userToMatchedTracks.empty(), ());
WriteSize(sink, userToMatchedTracks.size());
for (auto const & userIt : userToMatchedTracks)
{
rw::Write(sink, userIt.first);
std::vector<MatchedTrack> const & tracks = userIt.second;
CHECK(!tracks.empty(), ());
WriteSize(sink, tracks.size());
for (MatchedTrack const & track : tracks)
{
CHECK(!track.empty(), ());
WriteSize(sink, track.size());
for (MatchedTrackPoint const & point : track)
Serialize(point.GetSegment(), sink);
std::vector<DataPoint> dataPoints;
dataPoints.reserve(track.size());
for (MatchedTrackPoint const & point : track)
dataPoints.push_back(point.GetDataPoint());
std::vector<uint8_t> buffer;
MemWriter<decltype(buffer)> memWriter(buffer);
coding::TrafficGPSEncoder::SerializeDataPoints(coding::TrafficGPSEncoder::kLatestVersion,
memWriter, dataPoints);
WriteSize(sink, buffer.size());
sink.Write(buffer.data(), buffer.size());
}
}
}
}
template <class Source>
void Deserialize(MwmToMatchedTracks & mwmToMatchedTracks, Source & src)
{
mwmToMatchedTracks.clear();
auto const numMmws = ReadSize(src);
for (size_t iMwm = 0; iMwm < numMmws; ++iMwm)
{
std::string mwmName;
rw::Read(src, mwmName);
auto const mwmId = m_numMwmIds->GetId(platform::CountryFile(mwmName));
UserToMatchedTracks & userToMatchedTracks = mwmToMatchedTracks[mwmId];
auto const numUsers = ReadSize(src);
CHECK_NOT_EQUAL(numUsers, 0, ());
for (size_t iUser = 0; iUser < numUsers; ++iUser)
{
std::string user;
rw::Read(src, user);
std::vector<MatchedTrack> & tracks = userToMatchedTracks[user];
auto const numTracks = ReadSize(src);
CHECK_NOT_EQUAL(numTracks, 0, ());
tracks.resize(numTracks);
for (size_t iTrack = 0; iTrack < numTracks; ++iTrack)
{
auto const numSegments = ReadSize(src);
CHECK_NOT_EQUAL(numSegments, 0, ());
std::vector<routing::Segment> segments;
segments.resize(numSegments);
for (size_t iSeg = 0; iSeg < numSegments; ++iSeg)
Deserialize(mwmId, segments[iSeg], src);
std::vector<uint8_t> buffer;
auto const bufferSize = ReadSize(src);
buffer.resize(bufferSize);
src.Read(buffer.data(), bufferSize);
MemReader memReader(buffer.data(), bufferSize);
ReaderSource<MemReader> memSrc(memReader);
std::vector<DataPoint> dataPoints;
coding::TrafficGPSEncoder::DeserializeDataPoints(
coding::TrafficGPSEncoder::kLatestVersion, memSrc, dataPoints);
CHECK_EQUAL(numSegments, dataPoints.size(), ("mwm:", mwmName, "user:", user));
MatchedTrack & track = tracks[iTrack];
track.reserve(numSegments);
for (size_t iPoint = 0; iPoint < numSegments; ++iPoint)
track.emplace_back(dataPoints[iPoint], segments[iPoint]);
}
}
}
}
private:
static uint8_t constexpr kForward = 0;
static uint8_t constexpr kBackward = 1;
template <class Sink>
static void WriteSize(Sink & sink, size_t size)
{
WriteVarUint(sink, base::checked_cast<uint64_t>(size));
}
template <class Source>
static size_t ReadSize(Source & src)
{
return base::checked_cast<size_t>(ReadVarUint<uint64_t>(src));
}
template <class Sink>
static void Serialize(routing::Segment const & segment, Sink & sink)
{
WriteToSink(sink, segment.GetFeatureId());
WriteToSink(sink, segment.GetSegmentIdx());
auto const direction = segment.IsForward() ? kForward : kBackward;
WriteToSink(sink, direction);
}
template <class Source>
static void Deserialize(routing::NumMwmId numMwmId, routing::Segment & segment, Source & src)
{
auto const featureId = ReadPrimitiveFromSource<uint32_t>(src);
auto const segmentIdx = ReadPrimitiveFromSource<uint32_t>(src);
auto const direction = ReadPrimitiveFromSource<uint8_t>(src);
segment = {numMwmId, featureId, segmentIdx, direction == kForward};
}
std::shared_ptr<routing::NumMwmIds> m_numMwmIds;
};
} // namespace track_analyzing
|
