open-vector-tile 1.11.1

This library reads/writes The Open Vector Tiles 1.0 Specification
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

use crate::{
    VectorFeature, VectorLayerMethods,
    base::BaseVectorLayer,
    open::{
        ColumnCacheReader, ColumnCacheWriter, Extent, OpenVectorFeature, decode_shape,
        encode_shape, read_feature, write_feature,
    },
};
use alloc::{rc::Rc, string::String, vec::Vec};
use core::cell::RefCell;
use pbf::{ProtoRead, Protobuf};
use s2json::Shape;

/// The Open Vector Layer class represents a layer in an Open Vector Tile.
/// Contains an extent, name, version, and features.
/// The features will utilize the layer extent to decode geometry.
#[derive(Debug)]
pub struct OpenVectorLayer {
    /// the version of the vector tile
    pub version: u16,
    /// the name of the layer
    pub name: String,
    /// the extent of the vector layer
    pub extent: Extent,
    /// the features in the layer
    pub features: Vec<OpenVectorFeature>,
    shape: Option<Shape>,
    m_shape: Option<Shape>,
    cache: Rc<RefCell<ColumnCacheReader>>,
}
impl OpenVectorLayer {
    /// Create a new OpenVectorLayer
    pub fn new(cache: Rc<RefCell<ColumnCacheReader>>) -> OpenVectorLayer {
        OpenVectorLayer {
            version: 1,
            name: String::new(),
            extent: Extent::default(),
            shape: None,
            m_shape: None,
            features: Vec::new(),
            cache,
        }
    }
}
impl VectorLayerMethods for OpenVectorLayer {
    fn version(&self) -> u16 {
        self.version
    }
    fn name(&self) -> String {
        self.name.clone()
    }
    fn extent(&self) -> usize {
        self.extent.into()
    }
    fn len(&self) -> usize {
        self.features.len()
    }
    fn is_empty(&self) -> bool {
        self.features.is_empty()
    }
    fn feature(&mut self, i: usize) -> Option<VectorFeature<'_>> {
        self.features.get_mut(i).map(Into::into)
    }
}
impl ProtoRead for OpenVectorLayer {
    fn read(&mut self, tag: u64, pb: &mut Protobuf) {
        match tag {
            1 => self.version = pb.read_varint::<u16>(),
            2 => {
                self.name = {
                    let mut cache = self.cache.borrow_mut();
                    cache.get_string(pb.read_varint())
                }
            }
            3 => self.extent = pb.read_varint::<Extent>(),
            4 => self.features.push(read_feature(
                pb.read_bytes(),
                self.extent,
                self.cache.clone(),
                &self.shape.clone().unwrap_or_default(),
                self.m_shape.clone().unwrap_or_default(),
            )),
            5 => {
                self.shape = {
                    let mut cache = self.cache.borrow_mut();
                    Some(decode_shape(pb.read_varint(), &mut cache))
                }
            }
            6 => {
                self.m_shape = {
                    let mut cache: core::cell::RefMut<ColumnCacheReader> = self.cache.borrow_mut();
                    Some(decode_shape(pb.read_varint(), &mut cache))
                }
            }
            _ => panic!("unknown tag: {}", tag),
        }
    }
}

/// Write the layer to a protobuf
pub fn write_layer(layer: &mut BaseVectorLayer, cache: &mut ColumnCacheWriter) -> Vec<u8> {
    let mut pbf = Protobuf::new();

    pbf.write_varint_field(1, layer.version);
    pbf.write_varint_field(2, cache.add_string(layer.name.clone()));
    pbf.write_varint_field(3, layer.extent);
    pbf.write_varint_field(5, encode_shape(&layer.shape, cache));
    if let Some(ref m_shape) = layer.m_shape {
        pbf.write_varint_field(6, encode_shape(m_shape, cache));
    }

    // sort by feature type
    layer.features.sort_by_key(|a| a.get_type());

    for feature in &layer.features {
        pbf.write_bytes_field(
            4,
            &write_feature(feature, &layer.shape, layer.m_shape.as_ref(), cache),
        );
    }

    pbf.take()
}