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

Committed 12 Aug 2024 09:02PM UTC coverage: 27.612% (+4.4%) from 23.175%

Build # #17

Build Type

push

Committed by Mr Martian

Commit Message

tests moving along

Run Details

1915 of 2437 new or added lines in 17 files covered. (78.58%)

14 existing lines in 5 files now uncovered.

11082 of 40134 relevant lines covered (27.61%)

105.18 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::VectorLayerMethods;

use pbf::{ProtoRead, Protobuf};

use core::cell::RefCell;

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

/// Mapbox specification for a Layer
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: Vec<MapboxVectorFeature>,
    /// 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>>, end: usize, is_s2: bool) -> MapboxVectorLayer {
        let pbf_clone = pbf.clone();
        let mut mvl = MapboxVectorLayer {
            version: 5,
            name: String::new(),
            extent: 4_096,
            is_s2,
            pbf,
            keys: Rc::new(RefCell::new(Vec::new())),
            values: Rc::new(RefCell::new(Vec::new())),
            features: Vec::new(),
        };

        let mut tmp_pbf = pbf_clone.borrow_mut();
        tmp_pbf.read_fields::<MapboxVectorLayer>(&mut mvl, Some(end));

        mvl
    }
}
impl VectorLayerMethods for MapboxVectorLayer {
    fn version(&self) -> u16 {
        self.version
    }
    fn name(&self) -> String {
        self.name.clone()
    }
    fn extent(&self) -> usize {
        self.extent
    }
}
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 => {
                let mut feature = MapboxVectorFeature::new(
                    self.pbf.clone(),
                    self.is_s2,
                    self.extent,
                    self.version,
                    self.keys.clone(),
                    self.values.clone(),
                );
                pb.read_message(&mut feature);
                self.features.push(feature);
            }
            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>(),
            _ => panic!("unknown tag: {}", tag),
        }
    }
}

/// 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));
    }
    // keys and values
    for key in keys.keys() {
        pbf.write_string_field(3, key);
    }
    for value in values.keys() {
        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::VectorLayerMethods;
4
5	use pbf::{ProtoRead, Protobuf};
6
7	use core::cell::RefCell;
8
9	use alloc::collections::BTreeMap;
10	use alloc::rc::Rc;
11	use alloc::string::String;
12	use alloc::vec::Vec;
13
14	/// Mapbox specification for a Layer
15	pub struct MapboxVectorLayer {
16	/// the version of the vector tile layer.
17	pub version: u16,
18	/// the name of the layer
19	pub name: String,
20	/// the extent of the vector layer
21	pub extent: usize,
22	/// the features in the layer
23	pub features: Vec<MapboxVectorFeature>,
24	/// whether or not the layer is an s2 layer. This is an extension to the Mapbox spec and not used
25	/// in production by most tools
26	is_s2: bool,
27	/// a reference to the pbf
28	pbf: Rc<RefCell<Protobuf>>,
29	/// key store used by features
30	keys: Rc<RefCell<Vec<String>>>,
31	/// value store used by features
32	values: Rc<RefCell<Vec<Value>>>,
33	}
34	impl MapboxVectorLayer {
35	/// Create a new MapboxVectorLayer
NEW 36	pub fn new(pbf: Rc<RefCell<Protobuf>>, end: usize, is_s2: bool) -> MapboxVectorLayer {	×
37	let pbf_clone = pbf.clone();	×
38	let mut mvl = MapboxVectorLayer {	×
39	version: 5,	×
40	name: String::new(),	×
41	extent: 4_096,	×
42	is_s2,	×
43	pbf,	×
44	keys: Rc::new(RefCell::new(Vec::new())),	×
45	values: Rc::new(RefCell::new(Vec::new())),	×
46	features: Vec::new(),	×
47	};	×
48		×
49	let mut tmp_pbf = pbf_clone.borrow_mut();	×
50	tmp_pbf.read_fields::<MapboxVectorLayer>(&mut mvl, Some(end));	×
51		×
52	mvl	×
53	}	×
54	}
55	impl VectorLayerMethods for MapboxVectorLayer {
56	fn version(&self) -> u16 {	×
57	self.version	×
58	}	×
59	fn name(&self) -> String {	×
60	self.name.clone()	×
61	}	×
62	fn extent(&self) -> usize {	×
63	self.extent	×
64	}	×
65	}
66	impl ProtoRead for MapboxVectorLayer {
67	fn read(&mut self, tag: u64, pb: &mut Protobuf) {	×
68	match tag {	×
69	15 => self.version = pb.read_varint::<u16>(),	×
70	1 => self.name = pb.read_string(),	×
71	2 => {	×
72	let mut feature = MapboxVectorFeature::new(	×
73	self.pbf.clone(),	×
74	self.is_s2,	×
75	self.extent,	×
76	self.version,	×
NEW 77	self.keys.clone(),	×
NEW 78	self.values.clone(),	×
79	);	×
80	pb.read_message(&mut feature);	×
81	self.features.push(feature);	×
NEW 82	}	×
83	3 => {	×
84	self.keys.borrow_mut().push(pb.read_string());	×
NEW 85	}	×
86	4 => {	×
87	let mut value = Value::Null;	×
88	pb.read_message(&mut value);	×
89	self.values.borrow_mut().push(value);	×
NEW 90	}	×
91	5 => self.extent = pb.read_varint::<usize>(),	×
92	_ => panic!("unknown tag: {}", tag),	×
93	}
94	}	×
95	}
96
97	/// Write a layer to a protobuffer using the S2 Specification
NEW 98	pub fn write_layer(layer: &BaseVectorLayer) -> Vec<u8> {	×
NEW 99	let mut pbf = Protobuf::new();	×
NEW 100	let mut keys: BTreeMap<String, usize> = BTreeMap::new();	×
NEW 101	let mut values: BTreeMap<Value, usize> = BTreeMap::new();	×
NEW 102		×
NEW 103	pbf.write_varint_field(15, layer.version as u64);	×
NEW 104	pbf.write_string_field(1, &layer.name);	×
NEW 105	for feature in layer.features.iter() {	×
NEW 106	pbf.write_bytes_field(2, &write_feature(feature, &mut keys, &mut values));	×
NEW 107	}	×
108	// keys and values
NEW 109	for key in keys.keys() {	×
NEW 110	pbf.write_string_field(3, key);	×
NEW 111	}	×
NEW 112	for value in values.keys() {	×
NEW 113	pbf.write_message(4, value);	×
NEW 114	}	×
NEW 115	pbf.write_varint_field(5, layer.extent);	×
NEW 116		×
NEW 117	pbf.take()	×
NEW 118	}	×

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

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