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

Committed 03 May 2025 04:21AM UTC coverage: 98.815% (+0.1%) from 98.678%

Build # #67

Build Type

push

Committed by Mr Martian

Commit Message

migrate to stable

Run Details

9510 of 9624 relevant lines covered (98.82%)

68.44 hits per line

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

97.7

/rust/mapbox/vector_layer.rs

use crate::{
    VectorFeatureMethods, VectorLayerMethods,
    base::BaseVectorLayer,
    mapbox::{MapboxVectorFeature, write_feature},
};
use alloc::{
    collections::{BTreeMap, btree_map::Entry},
    rc::Rc,
    string::String,
    vec::Vec,
};
use core::cell::RefCell;
use pbf::{ProtoRead, Protobuf};
use s2json::PrimitiveValue;

/// 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<PrimitiveValue>>>,
}
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
            Some(self.features.get_mut(&i).unwrap() as &mut dyn VectorFeatureMethods)
        } else {
            // Safe to unwrap since we just checked the key exists
            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 = PrimitiveValue::Null;
                pb.read_message(&mut value);
                self.values.borrow_mut().push(value);
            }
            5 => self.extent = pb.read_varint::<usize>(),
            _ => panic!("Unknown layer type"),
        }
    }
}

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

    pbf.write_varint_field(15, if mapbox_support { 1 } else { 5 });
    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, mapbox_support));
    }
    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<(PrimitiveValue, 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 as usize);

    pbf.take()
}

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

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

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