1#![allow(non_snake_case)]
4#![allow(non_upper_case_globals)]
5#![allow(non_camel_case_types)]
6#![allow(unused_imports)]
7#![allow(unknown_lints)]
8#![allow(clippy::all)]
9#![cfg_attr(rustfmt, rustfmt_skip)]
10
11
12use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result};
13use quick_protobuf::sizeofs::*;
14use super::*;
15
16#[derive(Debug, Default, PartialEq, Clone)]
17pub struct HeaderBlock {
18 pub bbox: Option<HeaderBBox>,
19 pub required_features: Vec<String>,
20 pub optional_features: Vec<String>,
21 pub writingprogram: Option<String>,
22 pub source: Option<String>,
23 pub osmosis_replication_timestamp: Option<i64>,
24 pub osmosis_replication_sequence_number: Option<i64>,
25 pub osmosis_replication_base_url: Option<String>,
26}
27
28impl<'a> MessageRead<'a> for HeaderBlock {
29 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
30 let mut msg = Self::default();
31 while !r.is_eof() {
32 match r.next_tag(bytes) {
33 Ok(10) => msg.bbox = Some(r.read_message::<HeaderBBox>(bytes)?),
34 Ok(34) => msg.required_features.push(r.read_string(bytes)?.to_owned()),
35 Ok(42) => msg.optional_features.push(r.read_string(bytes)?.to_owned()),
36 Ok(130) => msg.writingprogram = Some(r.read_string(bytes)?.to_owned()),
37 Ok(138) => msg.source = Some(r.read_string(bytes)?.to_owned()),
38 Ok(256) => msg.osmosis_replication_timestamp = Some(r.read_int64(bytes)?),
39 Ok(264) => msg.osmosis_replication_sequence_number = Some(r.read_int64(bytes)?),
40 Ok(274) => msg.osmosis_replication_base_url = Some(r.read_string(bytes)?.to_owned()),
41 Ok(t) => { r.read_unknown(bytes, t)?; }
42 Err(e) => return Err(e),
43 }
44 }
45 Ok(msg)
46 }
47}
48
49impl MessageWrite for HeaderBlock {
50 fn get_size(&self) -> usize {
51 0
52 + self.bbox.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
53 + self.required_features.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
54 + self.optional_features.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
55 + self.writingprogram.as_ref().map_or(0, |m| 2 + sizeof_len((m).len()))
56 + self.source.as_ref().map_or(0, |m| 2 + sizeof_len((m).len()))
57 + self.osmosis_replication_timestamp.as_ref().map_or(0, |m| 2 + sizeof_varint(*(m) as u64))
58 + self.osmosis_replication_sequence_number.as_ref().map_or(0, |m| 2 + sizeof_varint(*(m) as u64))
59 + self.osmosis_replication_base_url.as_ref().map_or(0, |m| 2 + sizeof_len((m).len()))
60 }
61
62 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
63 if let Some(ref s) = self.bbox { w.write_with_tag(10, |w| w.write_message(s))?; }
64 for s in &self.required_features { w.write_with_tag(34, |w| w.write_string(&**s))?; }
65 for s in &self.optional_features { w.write_with_tag(42, |w| w.write_string(&**s))?; }
66 if let Some(ref s) = self.writingprogram { w.write_with_tag(130, |w| w.write_string(&**s))?; }
67 if let Some(ref s) = self.source { w.write_with_tag(138, |w| w.write_string(&**s))?; }
68 if let Some(ref s) = self.osmosis_replication_timestamp { w.write_with_tag(256, |w| w.write_int64(*s))?; }
69 if let Some(ref s) = self.osmosis_replication_sequence_number { w.write_with_tag(264, |w| w.write_int64(*s))?; }
70 if let Some(ref s) = self.osmosis_replication_base_url { w.write_with_tag(274, |w| w.write_string(&**s))?; }
71 Ok(())
72 }
73}
74
75#[derive(Debug, Default, PartialEq, Clone)]
76pub struct HeaderBBox {
77 pub left: i64,
78 pub right: i64,
79 pub top: i64,
80 pub bottom: i64,
81}
82
83impl<'a> MessageRead<'a> for HeaderBBox {
84 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
85 let mut msg = Self::default();
86 while !r.is_eof() {
87 match r.next_tag(bytes) {
88 Ok(8) => msg.left = r.read_sint64(bytes)?,
89 Ok(16) => msg.right = r.read_sint64(bytes)?,
90 Ok(24) => msg.top = r.read_sint64(bytes)?,
91 Ok(32) => msg.bottom = r.read_sint64(bytes)?,
92 Ok(t) => { r.read_unknown(bytes, t)?; }
93 Err(e) => return Err(e),
94 }
95 }
96 Ok(msg)
97 }
98}
99
100impl MessageWrite for HeaderBBox {
101 fn get_size(&self) -> usize {
102 0
103 + 1 + sizeof_sint64(*(&self.left))
104 + 1 + sizeof_sint64(*(&self.right))
105 + 1 + sizeof_sint64(*(&self.top))
106 + 1 + sizeof_sint64(*(&self.bottom))
107 }
108
109 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
110 w.write_with_tag(8, |w| w.write_sint64(*&self.left))?;
111 w.write_with_tag(16, |w| w.write_sint64(*&self.right))?;
112 w.write_with_tag(24, |w| w.write_sint64(*&self.top))?;
113 w.write_with_tag(32, |w| w.write_sint64(*&self.bottom))?;
114 Ok(())
115 }
116}
117
118#[derive(Debug, Default, PartialEq, Clone)]
119pub struct PrimitiveBlock {
120 pub stringtable: StringTable,
121 pub primitivegroup: Vec<PrimitiveGroup>,
122 pub granularity: i32,
123 pub lat_offset: i64,
124 pub lon_offset: i64,
125 pub date_granularity: i32,
126}
127
128impl<'a> MessageRead<'a> for PrimitiveBlock {
129 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
130 let mut msg = PrimitiveBlock {
131 granularity: 100i32,
132 date_granularity: 1000i32,
133 ..Self::default()
134 };
135 while !r.is_eof() {
136 match r.next_tag(bytes) {
137 Ok(10) => msg.stringtable = r.read_message::<StringTable>(bytes)?,
138 Ok(18) => msg.primitivegroup.push(r.read_message::<PrimitiveGroup>(bytes)?),
139 Ok(136) => msg.granularity = r.read_int32(bytes)?,
140 Ok(152) => msg.lat_offset = r.read_int64(bytes)?,
141 Ok(160) => msg.lon_offset = r.read_int64(bytes)?,
142 Ok(144) => msg.date_granularity = r.read_int32(bytes)?,
143 Ok(t) => { r.read_unknown(bytes, t)?; }
144 Err(e) => return Err(e),
145 }
146 }
147 Ok(msg)
148 }
149}
150
151impl MessageWrite for PrimitiveBlock {
152 fn get_size(&self) -> usize {
153 0
154 + 1 + sizeof_len((&self.stringtable).get_size())
155 + self.primitivegroup.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
156 + if self.granularity == 100i32 { 0 } else { 2 + sizeof_varint(*(&self.granularity) as u64) }
157 + if self.lat_offset == 0i64 { 0 } else { 2 + sizeof_varint(*(&self.lat_offset) as u64) }
158 + if self.lon_offset == 0i64 { 0 } else { 2 + sizeof_varint(*(&self.lon_offset) as u64) }
159 + if self.date_granularity == 1000i32 { 0 } else { 2 + sizeof_varint(*(&self.date_granularity) as u64) }
160 }
161
162 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
163 w.write_with_tag(10, |w| w.write_message(&self.stringtable))?;
164 for s in &self.primitivegroup { w.write_with_tag(18, |w| w.write_message(s))?; }
165 if self.granularity != 100i32 { w.write_with_tag(136, |w| w.write_int32(*&self.granularity))?; }
166 if self.lat_offset != 0i64 { w.write_with_tag(152, |w| w.write_int64(*&self.lat_offset))?; }
167 if self.lon_offset != 0i64 { w.write_with_tag(160, |w| w.write_int64(*&self.lon_offset))?; }
168 if self.date_granularity != 1000i32 { w.write_with_tag(144, |w| w.write_int32(*&self.date_granularity))?; }
169 Ok(())
170 }
171}
172
173#[derive(Debug, Default, PartialEq, Clone)]
174pub struct PrimitiveGroup {
175 pub nodes: Vec<Node>,
176 pub dense: Option<DenseNodes>,
177 pub ways: Vec<Way>,
178 pub relations: Vec<Relation>,
179 pub changesets: Vec<ChangeSet>,
180}
181
182impl<'a> MessageRead<'a> for PrimitiveGroup {
183 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
184 let mut msg = Self::default();
185 while !r.is_eof() {
186 match r.next_tag(bytes) {
187 Ok(10) => msg.nodes.push(r.read_message::<Node>(bytes)?),
188 Ok(18) => msg.dense = Some(r.read_message::<DenseNodes>(bytes)?),
189 Ok(26) => msg.ways.push(r.read_message::<Way>(bytes)?),
190 Ok(34) => msg.relations.push(r.read_message::<Relation>(bytes)?),
191 Ok(42) => msg.changesets.push(r.read_message::<ChangeSet>(bytes)?),
192 Ok(t) => { r.read_unknown(bytes, t)?; }
193 Err(e) => return Err(e),
194 }
195 }
196 Ok(msg)
197 }
198}
199
200impl MessageWrite for PrimitiveGroup {
201 fn get_size(&self) -> usize {
202 0
203 + self.nodes.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
204 + self.dense.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
205 + self.ways.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
206 + self.relations.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
207 + self.changesets.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
208 }
209
210 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
211 for s in &self.nodes { w.write_with_tag(10, |w| w.write_message(s))?; }
212 if let Some(ref s) = self.dense { w.write_with_tag(18, |w| w.write_message(s))?; }
213 for s in &self.ways { w.write_with_tag(26, |w| w.write_message(s))?; }
214 for s in &self.relations { w.write_with_tag(34, |w| w.write_message(s))?; }
215 for s in &self.changesets { w.write_with_tag(42, |w| w.write_message(s))?; }
216 Ok(())
217 }
218}
219
220#[derive(Debug, Default, PartialEq, Clone)]
221pub struct StringTable {
222 pub s: Vec<Vec<u8>>,
223}
224
225impl<'a> MessageRead<'a> for StringTable {
226 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
227 let mut msg = Self::default();
228 while !r.is_eof() {
229 match r.next_tag(bytes) {
230 Ok(10) => msg.s.push(r.read_bytes(bytes)?.to_owned()),
231 Ok(t) => { r.read_unknown(bytes, t)?; }
232 Err(e) => return Err(e),
233 }
234 }
235 Ok(msg)
236 }
237}
238
239impl MessageWrite for StringTable {
240 fn get_size(&self) -> usize {
241 0
242 + self.s.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
243 }
244
245 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
246 for s in &self.s { w.write_with_tag(10, |w| w.write_bytes(&**s))?; }
247 Ok(())
248 }
249}
250
251#[derive(Debug, Default, PartialEq, Clone)]
252pub struct Info {
253 pub version: i32,
254 pub timestamp: Option<i64>,
255 pub changeset: Option<i64>,
256 pub uid: Option<i32>,
257 pub user_sid: Option<u32>,
258 pub visible: Option<bool>,
259}
260
261impl<'a> MessageRead<'a> for Info {
262 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
263 let mut msg = Info {
264 version: -1i32,
265 ..Self::default()
266 };
267 while !r.is_eof() {
268 match r.next_tag(bytes) {
269 Ok(8) => msg.version = r.read_int32(bytes)?,
270 Ok(16) => msg.timestamp = Some(r.read_int64(bytes)?),
271 Ok(24) => msg.changeset = Some(r.read_int64(bytes)?),
272 Ok(32) => msg.uid = Some(r.read_int32(bytes)?),
273 Ok(40) => msg.user_sid = Some(r.read_uint32(bytes)?),
274 Ok(48) => msg.visible = Some(r.read_bool(bytes)?),
275 Ok(t) => { r.read_unknown(bytes, t)?; }
276 Err(e) => return Err(e),
277 }
278 }
279 Ok(msg)
280 }
281}
282
283impl MessageWrite for Info {
284 fn get_size(&self) -> usize {
285 0
286 + if self.version == -1i32 { 0 } else { 1 + sizeof_varint(*(&self.version) as u64) }
287 + self.timestamp.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
288 + self.changeset.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
289 + self.uid.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
290 + self.user_sid.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
291 + self.visible.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
292 }
293
294 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
295 if self.version != -1i32 { w.write_with_tag(8, |w| w.write_int32(*&self.version))?; }
296 if let Some(ref s) = self.timestamp { w.write_with_tag(16, |w| w.write_int64(*s))?; }
297 if let Some(ref s) = self.changeset { w.write_with_tag(24, |w| w.write_int64(*s))?; }
298 if let Some(ref s) = self.uid { w.write_with_tag(32, |w| w.write_int32(*s))?; }
299 if let Some(ref s) = self.user_sid { w.write_with_tag(40, |w| w.write_uint32(*s))?; }
300 if let Some(ref s) = self.visible { w.write_with_tag(48, |w| w.write_bool(*s))?; }
301 Ok(())
302 }
303}
304
305#[derive(Debug, Default, PartialEq, Clone)]
306pub struct DenseInfo {
307 pub version: Vec<i32>,
308 pub timestamp: Vec<i64>,
309 pub changeset: Vec<i64>,
310 pub uid: Vec<i32>,
311 pub user_sid: Vec<i32>,
312 pub visible: Vec<bool>,
313}
314
315impl<'a> MessageRead<'a> for DenseInfo {
316 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
317 let mut msg = Self::default();
318 while !r.is_eof() {
319 match r.next_tag(bytes) {
320 Ok(10) => msg.version = r.read_packed(bytes, |r, bytes| Ok(r.read_int32(bytes)?))?,
321 Ok(18) => msg.timestamp = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?,
322 Ok(26) => msg.changeset = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?,
323 Ok(34) => msg.uid = r.read_packed(bytes, |r, bytes| Ok(r.read_sint32(bytes)?))?,
324 Ok(42) => msg.user_sid = r.read_packed(bytes, |r, bytes| Ok(r.read_sint32(bytes)?))?,
325 Ok(50) => msg.visible = r.read_packed(bytes, |r, bytes| Ok(r.read_bool(bytes)?))?,
326 Ok(t) => { r.read_unknown(bytes, t)?; }
327 Err(e) => return Err(e),
328 }
329 }
330 Ok(msg)
331 }
332}
333
334impl MessageWrite for DenseInfo {
335 fn get_size(&self) -> usize {
336 0
337 + if self.version.is_empty() { 0 } else { 1 + sizeof_len(self.version.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
338 + if self.timestamp.is_empty() { 0 } else { 1 + sizeof_len(self.timestamp.iter().map(|s| sizeof_sint64(*(s))).sum::<usize>()) }
339 + if self.changeset.is_empty() { 0 } else { 1 + sizeof_len(self.changeset.iter().map(|s| sizeof_sint64(*(s))).sum::<usize>()) }
340 + if self.uid.is_empty() { 0 } else { 1 + sizeof_len(self.uid.iter().map(|s| sizeof_sint32(*(s))).sum::<usize>()) }
341 + if self.user_sid.is_empty() { 0 } else { 1 + sizeof_len(self.user_sid.iter().map(|s| sizeof_sint32(*(s))).sum::<usize>()) }
342 + if self.visible.is_empty() { 0 } else { 1 + sizeof_len(self.visible.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
343 }
344
345 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
346 w.write_packed_with_tag(10, &self.version, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?;
347 w.write_packed_with_tag(18, &self.timestamp, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?;
348 w.write_packed_with_tag(26, &self.changeset, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?;
349 w.write_packed_with_tag(34, &self.uid, |w, m| w.write_sint32(*m), &|m| sizeof_sint32(*(m)))?;
350 w.write_packed_with_tag(42, &self.user_sid, |w, m| w.write_sint32(*m), &|m| sizeof_sint32(*(m)))?;
351 w.write_packed_with_tag(50, &self.visible, |w, m| w.write_bool(*m), &|m| sizeof_varint(*(m) as u64))?;
352 Ok(())
353 }
354}
355
356#[derive(Debug, Default, PartialEq, Clone)]
357pub struct ChangeSet {
358 pub id: i64,
359}
360
361impl<'a> MessageRead<'a> for ChangeSet {
362 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
363 let mut msg = Self::default();
364 while !r.is_eof() {
365 match r.next_tag(bytes) {
366 Ok(8) => msg.id = r.read_int64(bytes)?,
367 Ok(t) => { r.read_unknown(bytes, t)?; }
368 Err(e) => return Err(e),
369 }
370 }
371 Ok(msg)
372 }
373}
374
375impl MessageWrite for ChangeSet {
376 fn get_size(&self) -> usize {
377 0
378 + 1 + sizeof_varint(*(&self.id) as u64)
379 }
380
381 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
382 w.write_with_tag(8, |w| w.write_int64(*&self.id))?;
383 Ok(())
384 }
385}
386
387#[derive(Debug, Default, PartialEq, Clone)]
388pub struct Node {
389 pub id: i64,
390 pub keys: Vec<u32>,
391 pub vals: Vec<u32>,
392 pub info: Option<Info>,
393 pub lat: i64,
394 pub lon: i64,
395}
396
397impl<'a> MessageRead<'a> for Node {
398 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
399 let mut msg = Self::default();
400 while !r.is_eof() {
401 match r.next_tag(bytes) {
402 Ok(8) => msg.id = r.read_sint64(bytes)?,
403 Ok(18) => msg.keys = r.read_packed(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?,
404 Ok(26) => msg.vals = r.read_packed(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?,
405 Ok(34) => msg.info = Some(r.read_message::<Info>(bytes)?),
406 Ok(64) => msg.lat = r.read_sint64(bytes)?,
407 Ok(72) => msg.lon = r.read_sint64(bytes)?,
408 Ok(t) => { r.read_unknown(bytes, t)?; }
409 Err(e) => return Err(e),
410 }
411 }
412 Ok(msg)
413 }
414}
415
416impl MessageWrite for Node {
417 fn get_size(&self) -> usize {
418 0
419 + 1 + sizeof_sint64(*(&self.id))
420 + if self.keys.is_empty() { 0 } else { 1 + sizeof_len(self.keys.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
421 + if self.vals.is_empty() { 0 } else { 1 + sizeof_len(self.vals.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
422 + self.info.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
423 + 1 + sizeof_sint64(*(&self.lat))
424 + 1 + sizeof_sint64(*(&self.lon))
425 }
426
427 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
428 w.write_with_tag(8, |w| w.write_sint64(*&self.id))?;
429 w.write_packed_with_tag(18, &self.keys, |w, m| w.write_uint32(*m), &|m| sizeof_varint(*(m) as u64))?;
430 w.write_packed_with_tag(26, &self.vals, |w, m| w.write_uint32(*m), &|m| sizeof_varint(*(m) as u64))?;
431 if let Some(ref s) = self.info { w.write_with_tag(34, |w| w.write_message(s))?; }
432 w.write_with_tag(64, |w| w.write_sint64(*&self.lat))?;
433 w.write_with_tag(72, |w| w.write_sint64(*&self.lon))?;
434 Ok(())
435 }
436}
437
438#[derive(Debug, Default, PartialEq, Clone)]
439pub struct DenseNodes {
440 pub id: Vec<i64>,
441 pub denseinfo: Option<DenseInfo>,
442 pub lat: Vec<i64>,
443 pub lon: Vec<i64>,
444 pub keys_vals: Vec<i32>,
445}
446
447impl<'a> MessageRead<'a> for DenseNodes {
448 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
449 let mut msg = Self::default();
450 while !r.is_eof() {
451 match r.next_tag(bytes) {
452 Ok(10) => msg.id = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?,
453 Ok(42) => msg.denseinfo = Some(r.read_message::<DenseInfo>(bytes)?),
454 Ok(66) => msg.lat = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?,
455 Ok(74) => msg.lon = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?,
456 Ok(82) => msg.keys_vals = r.read_packed(bytes, |r, bytes| Ok(r.read_int32(bytes)?))?,
457 Ok(t) => { r.read_unknown(bytes, t)?; }
458 Err(e) => return Err(e),
459 }
460 }
461 Ok(msg)
462 }
463}
464
465impl MessageWrite for DenseNodes {
466 fn get_size(&self) -> usize {
467 0
468 + if self.id.is_empty() { 0 } else { 1 + sizeof_len(self.id.iter().map(|s| sizeof_sint64(*(s))).sum::<usize>()) }
469 + self.denseinfo.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
470 + if self.lat.is_empty() { 0 } else { 1 + sizeof_len(self.lat.iter().map(|s| sizeof_sint64(*(s))).sum::<usize>()) }
471 + if self.lon.is_empty() { 0 } else { 1 + sizeof_len(self.lon.iter().map(|s| sizeof_sint64(*(s))).sum::<usize>()) }
472 + if self.keys_vals.is_empty() { 0 } else { 1 + sizeof_len(self.keys_vals.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
473 }
474
475 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
476 w.write_packed_with_tag(10, &self.id, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?;
477 if let Some(ref s) = self.denseinfo { w.write_with_tag(42, |w| w.write_message(s))?; }
478 w.write_packed_with_tag(66, &self.lat, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?;
479 w.write_packed_with_tag(74, &self.lon, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?;
480 w.write_packed_with_tag(82, &self.keys_vals, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?;
481 Ok(())
482 }
483}
484
485#[derive(Debug, Default, PartialEq, Clone)]
486pub struct Way {
487 pub id: i64,
488 pub keys: Vec<u32>,
489 pub vals: Vec<u32>,
490 pub info: Option<Info>,
491 pub refs: Vec<i64>,
492}
493
494impl<'a> MessageRead<'a> for Way {
495 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
496 let mut msg = Self::default();
497 while !r.is_eof() {
498 match r.next_tag(bytes) {
499 Ok(8) => msg.id = r.read_int64(bytes)?,
500 Ok(18) => msg.keys = r.read_packed(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?,
501 Ok(26) => msg.vals = r.read_packed(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?,
502 Ok(34) => msg.info = Some(r.read_message::<Info>(bytes)?),
503 Ok(66) => msg.refs = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?,
504 Ok(t) => { r.read_unknown(bytes, t)?; }
505 Err(e) => return Err(e),
506 }
507 }
508 Ok(msg)
509 }
510}
511
512impl MessageWrite for Way {
513 fn get_size(&self) -> usize {
514 0
515 + 1 + sizeof_varint(*(&self.id) as u64)
516 + if self.keys.is_empty() { 0 } else { 1 + sizeof_len(self.keys.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
517 + if self.vals.is_empty() { 0 } else { 1 + sizeof_len(self.vals.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
518 + self.info.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
519 + if self.refs.is_empty() { 0 } else { 1 + sizeof_len(self.refs.iter().map(|s| sizeof_sint64(*(s))).sum::<usize>()) }
520 }
521
522 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
523 w.write_with_tag(8, |w| w.write_int64(*&self.id))?;
524 w.write_packed_with_tag(18, &self.keys, |w, m| w.write_uint32(*m), &|m| sizeof_varint(*(m) as u64))?;
525 w.write_packed_with_tag(26, &self.vals, |w, m| w.write_uint32(*m), &|m| sizeof_varint(*(m) as u64))?;
526 if let Some(ref s) = self.info { w.write_with_tag(34, |w| w.write_message(s))?; }
527 w.write_packed_with_tag(66, &self.refs, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?;
528 Ok(())
529 }
530}
531
532#[derive(Debug, Default, PartialEq, Clone)]
533pub struct Relation {
534 pub id: i64,
535 pub keys: Vec<u32>,
536 pub vals: Vec<u32>,
537 pub info: Option<Info>,
538 pub roles_sid: Vec<i32>,
539 pub memids: Vec<i64>,
540 pub types: Vec<mod_Relation::MemberType>,
541}
542
543impl<'a> MessageRead<'a> for Relation {
544 fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
545 let mut msg = Self::default();
546 while !r.is_eof() {
547 match r.next_tag(bytes) {
548 Ok(8) => msg.id = r.read_int64(bytes)?,
549 Ok(18) => msg.keys = r.read_packed(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?,
550 Ok(26) => msg.vals = r.read_packed(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?,
551 Ok(34) => msg.info = Some(r.read_message::<Info>(bytes)?),
552 Ok(66) => msg.roles_sid = r.read_packed(bytes, |r, bytes| Ok(r.read_int32(bytes)?))?,
553 Ok(74) => msg.memids = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?,
554 Ok(82) => msg.types = r.read_packed(bytes, |r, bytes| Ok(r.read_enum(bytes)?))?,
555 Ok(t) => { r.read_unknown(bytes, t)?; }
556 Err(e) => return Err(e),
557 }
558 }
559 Ok(msg)
560 }
561}
562
563impl MessageWrite for Relation {
564 fn get_size(&self) -> usize {
565 0
566 + 1 + sizeof_varint(*(&self.id) as u64)
567 + if self.keys.is_empty() { 0 } else { 1 + sizeof_len(self.keys.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
568 + if self.vals.is_empty() { 0 } else { 1 + sizeof_len(self.vals.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
569 + self.info.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
570 + if self.roles_sid.is_empty() { 0 } else { 1 + sizeof_len(self.roles_sid.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
571 + if self.memids.is_empty() { 0 } else { 1 + sizeof_len(self.memids.iter().map(|s| sizeof_sint64(*(s))).sum::<usize>()) }
572 + if self.types.is_empty() { 0 } else { 1 + sizeof_len(self.types.iter().map(|s| sizeof_varint(*(s) as u64)).sum::<usize>()) }
573 }
574
575 fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
576 w.write_with_tag(8, |w| w.write_int64(*&self.id))?;
577 w.write_packed_with_tag(18, &self.keys, |w, m| w.write_uint32(*m), &|m| sizeof_varint(*(m) as u64))?;
578 w.write_packed_with_tag(26, &self.vals, |w, m| w.write_uint32(*m), &|m| sizeof_varint(*(m) as u64))?;
579 if let Some(ref s) = self.info { w.write_with_tag(34, |w| w.write_message(s))?; }
580 w.write_packed_with_tag(66, &self.roles_sid, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?;
581 w.write_packed_with_tag(74, &self.memids, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?;
582 w.write_packed_with_tag(82, &self.types, |w, m| w.write_enum(*m as i32), &|m| sizeof_varint(*(m) as u64))?;
583 Ok(())
584 }
585}
586
587pub mod mod_Relation {
588
589
590#[derive(Debug, PartialEq, Eq, Clone, Copy)]
591pub enum MemberType {
592 NODE = 0,
593 WAY = 1,
594 RELATION = 2,
595}
596
597impl Default for MemberType {
598 fn default() -> Self {
599 MemberType::NODE
600 }
601}
602
603impl From<i32> for MemberType {
604 fn from(i: i32) -> Self {
605 match i {
606 0 => MemberType::NODE,
607 1 => MemberType::WAY,
608 2 => MemberType::RELATION,
609 _ => Self::default(),
610 }
611 }
612}
613
614impl<'a> From<&'a str> for MemberType {
615 fn from(s: &'a str) -> Self {
616 match s {
617 "NODE" => MemberType::NODE,
618 "WAY" => MemberType::WAY,
619 "RELATION" => MemberType::RELATION,
620 _ => Self::default(),
621 }
622 }
623}
624
625}
626