Open-S2 / open-vector-tile / #19

Committed 15 Aug 2024 12:44AM UTC coverage: 43.923% (+9.0%) from 34.908%

Build # #19

Build Type

push

Committed by Mr Martian

Commit Message

fix coveralls

Run Details

2349 of 5348 relevant lines covered (43.92%)

46.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/rust/mapbox/vector_layer.rs

use crate::base::BaseVectorLayer;
use crate::mapbox::{write_feature, MapboxVectorFeature, Value};
use crate::{VectorFeatureMethods, VectorLayerMethods};

use pbf::{ProtoRead, Protobuf};

use core::cell::RefCell;

use alloc::collections::btree_map::Entry;
use alloc::collections::BTreeMap;
use alloc::rc::Rc;
use alloc::string::String;
use alloc::vec::Vec;

/// Mapbox specification for a Layer
#[derive(Debug)]
pub struct MapboxVectorLayer {
    /// the version of the vector tile layer.
    pub version: u16,
    /// the name of the layer
    pub name: String,
    /// the extent of the vector layer
    pub extent: usize,
    /// the features in the layer
    pub features: BTreeMap<usize, MapboxVectorFeature>,
    /// track the positions of the features
    pub feature_positions: Vec<usize>,
    /// whether or not the layer is an s2 layer. This is an extension to the Mapbox spec and not used
    /// in production by most tools
    is_s2: bool,
    /// a reference to the pbf
    pbf: Rc<RefCell<Protobuf>>,
    /// key store used by features
    keys: Rc<RefCell<Vec<String>>>,
    /// value store used by features
    values: Rc<RefCell<Vec<Value>>>,
}
impl MapboxVectorLayer {
    /// Create a new MapboxVectorLayer
    pub fn new(pbf: Rc<RefCell<Protobuf>>, is_s2: bool) -> MapboxVectorLayer {
        MapboxVectorLayer {
            version: 5,
            name: String::new(),
            extent: 4_096,
            is_s2,
            pbf: pbf.clone(),
            keys: Rc::new(RefCell::new(Vec::new())),
            values: Rc::new(RefCell::new(Vec::new())),
            features: BTreeMap::new(),
            feature_positions: Vec::new(),
        }
    }
}
impl VectorLayerMethods for MapboxVectorLayer {
    fn version(&self) -> u16 {
        self.version
    }

    fn name(&self) -> String {
        self.name.clone()
    }

    fn extent(&self) -> usize {
        self.extent
    }

    /// the number of features in the layer
    fn len(&self) -> usize {
        self.feature_positions.len()
    }

    /// Check if the layer is empty
    fn is_empty(&self) -> bool {
        self.feature_positions.is_empty()
    }

    fn feature(&mut self, i: usize) -> Option<&mut dyn VectorFeatureMethods> {
        // First check if self.features already has the feature
        if let Entry::Vacant(e) = self.features.entry(i) {
            // Read the feature
            let mut feature = MapboxVectorFeature::new(
                self.pbf.clone(),
                self.is_s2,
                self.extent,
                self.version,
                self.keys.clone(),
                self.values.clone(),
            );
            let mut pbf = self.pbf.borrow_mut();
            pbf.set_pos(self.feature_positions[i]);
            pbf.read_message(&mut feature);
            e.insert(feature);

            // Now safely retrieve the inserted feature
            return Some(self.features.get_mut(&i).unwrap() as &mut dyn VectorFeatureMethods);
        } else {
            // Safe to unwrap since we just checked the key exists
            return Some(self.features.get_mut(&i).unwrap() as &mut dyn VectorFeatureMethods);
        }
    }
}
impl ProtoRead for MapboxVectorLayer {
    fn read(&mut self, tag: u64, pb: &mut Protobuf) {
        match tag {
            15 => self.version = pb.read_varint::<u16>(),
            1 => self.name = pb.read_string(),
            2 => self.feature_positions.push(pb.get_pos()),
            3 => {
                self.keys.borrow_mut().push(pb.read_string());
            }
            4 => {
                let mut value = Value::Null;
                pb.read_message(&mut value);
                self.values.borrow_mut().push(value);
            }
            5 => self.extent = pb.read_varint::<usize>(),
            _ => {} // do nothing
        }
    }
}

/// Write a layer to a protobuffer using the S2 Specification
pub fn write_layer(layer: &BaseVectorLayer) -> Vec<u8> {
    let mut pbf = Protobuf::new();
    let mut keys: BTreeMap<String, usize> = BTreeMap::new();
    let mut values: BTreeMap<Value, usize> = BTreeMap::new();

    pbf.write_varint_field(15, layer.version as u64);
    pbf.write_string_field(1, &layer.name);
    for feature in layer.features.iter() {
        pbf.write_bytes_field(2, &write_feature(feature, &mut keys, &mut values));
    }
    let mut keys: Vec<(String, usize)> = keys.into_iter().collect();
    keys.sort_by(|a, b| a.1.cmp(&b.1));
    // keys and values
    for (key, _) in keys.iter() {
        pbf.write_string_field(3, key);
    }
    let mut values: Vec<(Value, usize)> = values.into_iter().collect();
    values.sort_by(|a, b| a.1.cmp(&b.1));
    for (value, _) in values.iter() {
        pbf.write_message(4, value);
    }
    pbf.write_varint_field(5, layer.extent);

    pbf.take()
}

1	use crate::base::BaseVectorLayer;
2	use crate::mapbox::{write_feature, MapboxVectorFeature, Value};
3	use crate::{VectorFeatureMethods, VectorLayerMethods};
4
5	use pbf::{ProtoRead, Protobuf};
6
7	use core::cell::RefCell;
8
9	use alloc::collections::btree_map::Entry;
10	use alloc::collections::BTreeMap;
11	use alloc::rc::Rc;
12	use alloc::string::String;
13	use alloc::vec::Vec;
14
15	/// Mapbox specification for a Layer
16	#[derive(Debug)]
17	pub struct MapboxVectorLayer {
18	/// the version of the vector tile layer.
19	pub version: u16,
20	/// the name of the layer
21	pub name: String,
22	/// the extent of the vector layer
23	pub extent: usize,
24	/// the features in the layer
25	pub features: BTreeMap<usize, MapboxVectorFeature>,
26	/// track the positions of the features
27	pub feature_positions: Vec<usize>,
28	/// whether or not the layer is an s2 layer. This is an extension to the Mapbox spec and not used
29	/// in production by most tools
30	is_s2: bool,
31	/// a reference to the pbf
32	pbf: Rc<RefCell<Protobuf>>,
33	/// key store used by features
34	keys: Rc<RefCell<Vec<String>>>,
35	/// value store used by features
36	values: Rc<RefCell<Vec<Value>>>,
37	}
38	impl MapboxVectorLayer {
39	/// Create a new MapboxVectorLayer
40	pub fn new(pbf: Rc<RefCell<Protobuf>>, is_s2: bool) -> MapboxVectorLayer {	×
41	MapboxVectorLayer {	×
42	version: 5,	×
43	name: String::new(),	×
44	extent: 4_096,	×
45	is_s2,	×
46	pbf: pbf.clone(),	×
47	keys: Rc::new(RefCell::new(Vec::new())),	×
48	values: Rc::new(RefCell::new(Vec::new())),	×
49	features: BTreeMap::new(),	×
50	feature_positions: Vec::new(),	×
51	}	×
52	}	×
53	}
54	impl VectorLayerMethods for MapboxVectorLayer {
55	fn version(&self) -> u16 {	×
56	self.version	×
57	}	×
58
59	fn name(&self) -> String {	×
60	self.name.clone()	×
61	}	×
62
63	fn extent(&self) -> usize {	×
64	self.extent	×
65	}	×
66
67	/// the number of features in the layer
68	fn len(&self) -> usize {	×
69	self.feature_positions.len()	×
70	}	×
71
72	/// Check if the layer is empty
73	fn is_empty(&self) -> bool {	×
74	self.feature_positions.is_empty()	×
75	}	×
76
77	fn feature(&mut self, i: usize) -> Option<&mut dyn VectorFeatureMethods> {	×
78	// First check if self.features already has the feature
79	if let Entry::Vacant(e) = self.features.entry(i) {	×
80	// Read the feature
81	let mut feature = MapboxVectorFeature::new(	×
82	self.pbf.clone(),	×
83	self.is_s2,	×
84	self.extent,	×
85	self.version,	×
86	self.keys.clone(),	×
87	self.values.clone(),	×
88	);	×
89	let mut pbf = self.pbf.borrow_mut();	×
90	pbf.set_pos(self.feature_positions[i]);	×
91	pbf.read_message(&mut feature);	×
92	e.insert(feature);	×
93		×
94	// Now safely retrieve the inserted feature	×
95	return Some(self.features.get_mut(&i).unwrap() as &mut dyn VectorFeatureMethods);	×
96	} else {
97	// Safe to unwrap since we just checked the key exists
98	return Some(self.features.get_mut(&i).unwrap() as &mut dyn VectorFeatureMethods);	×
99	}
100	}	×
101	}
102	impl ProtoRead for MapboxVectorLayer {
103	fn read(&mut self, tag: u64, pb: &mut Protobuf) {	×
104	match tag {	×
105	15 => self.version = pb.read_varint::<u16>(),	×
106	1 => self.name = pb.read_string(),	×
107	2 => self.feature_positions.push(pb.get_pos()),	×
108	3 => {	×
109	self.keys.borrow_mut().push(pb.read_string());	×
110	}	×
111	4 => {	×
112	let mut value = Value::Null;	×
113	pb.read_message(&mut value);	×
114	self.values.borrow_mut().push(value);	×
115	}	×
116	5 => self.extent = pb.read_varint::<usize>(),	×
117	_ => {} // do nothing	×
118	}
119	}	×
120	}
121
122	/// Write a layer to a protobuffer using the S2 Specification
123	pub fn write_layer(layer: &BaseVectorLayer) -> Vec<u8> {	×
124	let mut pbf = Protobuf::new();	×
125	let mut keys: BTreeMap<String, usize> = BTreeMap::new();	×
126	let mut values: BTreeMap<Value, usize> = BTreeMap::new();	×
127		×
128	pbf.write_varint_field(15, layer.version as u64);	×
129	pbf.write_string_field(1, &layer.name);	×
130	for feature in layer.features.iter() {	×
131	pbf.write_bytes_field(2, &write_feature(feature, &mut keys, &mut values));	×
132	}	×
133	let mut keys: Vec<(String, usize)> = keys.into_iter().collect();	×
134	keys.sort_by(\|a, b\| a.1.cmp(&b.1));	×
135	// keys and values
136	for (key, _) in keys.iter() {	×
137	pbf.write_string_field(3, key);	×
138	}	×
139	let mut values: Vec<(Value, usize)> = values.into_iter().collect();	×
140	values.sort_by(\|a, b\| a.1.cmp(&b.1));	×
141	for (value, _) in values.iter() {	×
142	pbf.write_message(4, value);	×
143	}	×
144	pbf.write_varint_field(5, layer.extent);	×
145		×
146	pbf.take()	×
147	}	×

Open-S2 / open-vector-tile / #19

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous