routers_codec 0.1.3

Encoding and Decoding Primitives for Routers
Documentation 
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

//! A block item, used to decode a `BlobItem` into a `BlockItem`,
//! providing distinction for header and primitive elements, as well
//! as decoding fully, to element level.

use bytes::Buf;
use either::Either;
use flate2::read::ZlibDecoder;
use log::warn;
use prost::Message;
use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
use std::io::Read;

use crate::osm::blob::item::BlobItem;
use crate::osm::element::item::Element;
use crate::osm::element::item::ProcessedElement;
use crate::osm::{Blob, HeaderBlock, PrimitiveBlock, model::blob::Data};

pub enum BlockItem {
    HeaderBlock(HeaderBlock),
    PrimitiveBlock(PrimitiveBlock),
}

impl BlockItem {
    #[inline]
    pub(crate) fn from_blob_item(blob: &BlobItem, buf: &[u8]) -> Option<Self> {
        BlockItem::from_raw(blob, buf)
    }

    #[inline]
    fn from_raw(blob_item: &BlobItem, buf: &[u8]) -> Option<Self> {
        let data = buf.get(blob_item.range.clone())?;
        let blob = Blob::decode(data).ok()?;

        // Convert raw into actual. Handles ZLIB encoding.
        let data = BlockItem::from_blob(blob)?;
        BlockItem::from_data(data.as_slice(), blob_item)
    }

    #[inline]
    fn from_blob(blob: Blob) -> Option<Vec<u8>> {
        if let Some(Data::ZlibData(data)) = blob.data {
            return BlockItem::zlib_decode(data, blob.raw_size.unwrap_or(0) as usize);
        }

        warn!("Type {:?} not yet supported.", blob.data);
        None
    }

    #[inline]
    fn from_data(data: &[u8], blob: &BlobItem) -> Option<Self> {
        match blob.header.r#type.as_str() {
            "OSMData" => Some(BlockItem::PrimitiveBlock(
                PrimitiveBlock::decode(data).ok()?,
            )),
            "OSMHeader" => Some(BlockItem::HeaderBlock(HeaderBlock::decode(data).ok()?)),
            _ => None,
        }
    }

    #[inline]
    fn zlib_decode(data: prost::bytes::Bytes, raw_size: usize) -> Option<Vec<u8>> {
        let mut decoded = vec![0_u8; raw_size];
        ZlibDecoder::new(data.reader())
            .read_exact(&mut decoded)
            .ok()?;

        Some(decoded)
    }

    pub fn r#type(&self) -> &str {
        match self {
            BlockItem::HeaderBlock(_) => "HeaderBlock",
            BlockItem::PrimitiveBlock(_) => "PrimitiveBlock",
        }
    }

    #[inline]
    pub fn raw_element_iter(&self) -> impl Iterator<Item = Element<'_>> {
        match self {
            BlockItem::PrimitiveBlock(primitive) => Either::Left(
                primitive
                    .primitivegroup
                    .iter()
                    .flat_map(Element::from_group),
            ),
            BlockItem::HeaderBlock(_) => Either::Right(core::iter::empty()),
        }
    }

    #[inline]
    pub fn element_iter(&self) -> impl Iterator<Item = ProcessedElement> + '_ {
        match self {
            BlockItem::PrimitiveBlock(primitive) => Either::Left(
                primitive
                    .primitivegroup
                    .iter()
                    .flat_map(Element::from_group)
                    .flat_map(|element| ProcessedElement::from_raw(element, primitive)),
            ),
            BlockItem::HeaderBlock(_) => Either::Right(core::iter::empty()),
        }
    }

    #[inline]
    pub fn raw_par_iter(&mut self) -> impl ParallelIterator<Item = Element<'_>> + '_ {
        match self {
            BlockItem::PrimitiveBlock(primitive) => Either::Left(
                primitive
                    .primitivegroup
                    .par_iter()
                    .flat_map(Element::from_group),
            ),
            BlockItem::HeaderBlock(_) => Either::Right(rayon::iter::empty()),
        }
    }

    #[inline]
    pub fn par_iter(&mut self) -> impl ParallelIterator<Item = ProcessedElement> + '_ {
        match self {
            BlockItem::PrimitiveBlock(primitive) => Either::Left(
                primitive
                    .primitivegroup
                    .par_iter()
                    .flat_map(Element::from_group)
                    .flat_map(|element| ProcessedElement::from_raw(element, primitive)),
            ),
            BlockItem::HeaderBlock(_) => Either::Right(rayon::iter::empty()),
        }
    }
}