fast-mvt 0.6.2

Fast Mapbox Vector Tile (MVT) reader and writer
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

use std::fmt;
use std::num::NonZeroU32;

use super::feature::MvtFeatureRef;
use super::property::{MvtValueRef, value_ref};
use crate::generated::vector_tile::tile as proto_tile;
use crate::{DEFAULT_EXTENT, MvtError, MvtLayer, MvtResult};

#[derive(Copy, Clone)]
pub struct MvtLayerRef<'a>(&'a proto_tile::LayerView<'a>);

impl<'a> MvtLayerRef<'a> {
    pub(crate) fn new(view: &'a proto_tile::LayerView<'a>) -> Self {
        Self(view)
    }

    #[must_use]
    pub fn name(self) -> &'a str {
        self.0.name
    }

    #[must_use]
    pub fn version(self) -> u32 {
        self.0.version
    }

    #[must_use]
    pub fn extent(self) -> u32 {
        self.0.extent.unwrap_or(DEFAULT_EXTENT.get())
    }

    #[must_use]
    pub fn feature_count(self) -> usize {
        self.0.features.len()
    }

    #[must_use]
    pub fn is_empty(self) -> bool {
        self.0.features.is_empty()
    }

    #[must_use]
    pub fn keys(self) -> &'a [&'a str] {
        &self.0.keys
    }

    #[must_use]
    pub fn values(self) -> impl ExactSizeIterator<Item = MvtValueRef<'a>> {
        self.0.values.iter().map(value_ref)
    }

    #[must_use]
    pub fn features(self) -> impl ExactSizeIterator<Item = MvtFeatureRef<'a>> {
        self.0
            .features
            .iter()
            .map(move |feature| MvtFeatureRef::new(self.0, feature))
    }

    pub fn to_layer(self) -> MvtResult<MvtLayer> {
        let extent = match self.0.extent {
            Some(extent) => NonZeroU32::new(extent).ok_or(MvtError::InvalidExtent)?,
            None => DEFAULT_EXTENT,
        };
        self.features()
            .map(MvtFeatureRef::to_feature)
            .collect::<MvtResult<Vec<_>>>()
            .map(|features| MvtLayer {
                name: self.0.name.to_string(),
                extent,
                features,
            })
    }
}

impl fmt::Debug for MvtLayerRef<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(f, "  name: {}", self.name())?;
        writeln!(f, "  version: {}", self.version())?;
        writeln!(f, "  extent: {}", self.extent())?;
        for (index, feature) in self.features().enumerate() {
            writeln!(f, "  feature: {index}")?;
            // Each feature's `Debug` block is already newline-terminated.
            write!(f, "{feature:?}")?;
        }
        Ok(())
    }
}