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

Committed 17 Feb 2025 08:39PM UTC coverage: 40.419% (-58.3%) from 98.718%

Build # #49

Build Type

push

Committed by Mr Martian

Commit Message

setup a wasm build for experimentation; main rust didnt have no_std (bug)

Run Details

18 of 18 new or added lines in 3 files covered. (100.0%)

2956 existing lines in 15 files now uncovered.

2082 of 5151 relevant lines covered (40.42%)

107.98 hits per line

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

0.0

/rust/open/vector_layer.rs

use pbf::{ProtoRead, Protobuf};

use crate::{
    base::BaseVectorLayer,
    open::{
        decode_shape, encode_shape, read_feature, write_feature, ColumnCacheReader,
        ColumnCacheWriter, Extent, OpenVectorFeature, Shape,
    },
    VectorLayerMethods,
};

use core::cell::RefCell;

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

/// 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<&mut dyn crate::VectorFeatureMethods> {
        self.features.get_mut(i).map(|f| f as &mut dyn crate::VectorFeatureMethods)
    }
}
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))
                }
            }
            #[tarpaulin::skip]
            _ => 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()
}

1	use pbf::{ProtoRead, Protobuf};
2
3	use crate::{
4	base::BaseVectorLayer,
5	open::{
6	decode_shape, encode_shape, read_feature, write_feature, ColumnCacheReader,
7	ColumnCacheWriter, Extent, OpenVectorFeature, Shape,
8	},
9	VectorLayerMethods,
10	};
11
12	use core::cell::RefCell;
13
14	use alloc::rc::Rc;
15	use alloc::string::String;
16	use alloc::vec::Vec;
17
18	/// The Open Vector Layer class represents a layer in an Open Vector Tile.
19	/// Contains an extent, name, version, and features.
20	/// The features will utilize the layer extent to decode geometry.
21	#[derive(Debug)]
22	pub struct OpenVectorLayer {
23	/// the version of the vector tile
24	pub version: u16,
25	/// the name of the layer
26	pub name: String,
27	/// the extent of the vector layer
28	pub extent: Extent,
29	/// the features in the layer
30	pub features: Vec<OpenVectorFeature>,
31	shape: Option<Shape>,
32	m_shape: Option<Shape>,
33	cache: Rc<RefCell<ColumnCacheReader>>,
34	}
35	impl OpenVectorLayer {
36	/// Create a new OpenVectorLayer
UNCOV 37	pub fn new(cache: Rc<RefCell<ColumnCacheReader>>) -> OpenVectorLayer {	×
UNCOV 38	OpenVectorLayer {	×
UNCOV 39	version: 1,	×
UNCOV 40	name: String::new(),	×
UNCOV 41	extent: Extent::default(),	×
UNCOV 42	shape: None,	×
UNCOV 43	m_shape: None,	×
UNCOV 44	features: Vec::new(),	×
UNCOV 45	cache,	×
UNCOV 46	}	×
UNCOV 47	}	×
48	}
49	impl VectorLayerMethods for OpenVectorLayer {
UNCOV 50	fn version(&self) -> u16 {	×
UNCOV 51	self.version	×
UNCOV 52	}	×
UNCOV 53	fn name(&self) -> String {	×
UNCOV 54	self.name.clone()	×
UNCOV 55	}	×
UNCOV 56	fn extent(&self) -> usize {	×
UNCOV 57	self.extent.into()	×
UNCOV 58	}	×
UNCOV 59	fn len(&self) -> usize {	×
UNCOV 60	self.features.len()	×
UNCOV 61	}	×
UNCOV 62	fn is_empty(&self) -> bool {	×
UNCOV 63	self.features.is_empty()	×
UNCOV 64	}	×
UNCOV 65	fn feature(&mut self, i: usize) -> Option<&mut dyn crate::VectorFeatureMethods> {	×
UNCOV 66	self.features.get_mut(i).map(\|f\| f as &mut dyn crate::VectorFeatureMethods)	×
UNCOV 67	}	×
68	}
69	impl ProtoRead for OpenVectorLayer {
UNCOV 70	fn read(&mut self, tag: u64, pb: &mut Protobuf) {	×
UNCOV 71	match tag {	×
UNCOV 72	1 => self.version = pb.read_varint::<u16>(),	×
73	2 => {
UNCOV 74	self.name = {	×
UNCOV 75	let mut cache = self.cache.borrow_mut();	×
UNCOV 76	cache.get_string(pb.read_varint())	×
UNCOV 77	}	×
78	}
UNCOV 79	3 => self.extent = pb.read_varint::<Extent>(),	×
UNCOV 80	4 => self.features.push(read_feature(	×
UNCOV 81	pb.read_bytes(),	×
UNCOV 82	self.extent,	×
UNCOV 83	self.cache.clone(),	×
UNCOV 84	&self.shape.clone().unwrap_or_default(),	×
UNCOV 85	self.m_shape.clone().unwrap_or_default(),	×
UNCOV 86	)),	×
87	5 => {
UNCOV 88	self.shape = {	×
UNCOV 89	let mut cache = self.cache.borrow_mut();	×
UNCOV 90	Some(decode_shape(pb.read_varint(), &mut cache))	×
UNCOV 91	}	×
92	}
93	6 => {
UNCOV 94	self.m_shape = {	×
UNCOV 95	let mut cache: core::cell::RefMut<ColumnCacheReader> = self.cache.borrow_mut();	×
UNCOV 96	Some(decode_shape(pb.read_varint(), &mut cache))	×
UNCOV 97	}	×
98	}
99	#[tarpaulin::skip]
100	_ => panic!("unknown tag: {}", tag),	×
101	}
UNCOV 102	}	×
103	}
104
105	/// Write the layer to a protobuf
UNCOV 106	pub fn write_layer(layer: &mut BaseVectorLayer, cache: &mut ColumnCacheWriter) -> Vec<u8> {	×
UNCOV 107	let mut pbf = Protobuf::new();	×
UNCOV 108		×
UNCOV 109	pbf.write_varint_field(1, layer.version);	×
UNCOV 110	pbf.write_varint_field(2, cache.add_string(layer.name.clone()));	×
UNCOV 111	pbf.write_varint_field(3, layer.extent);	×
UNCOV 112	pbf.write_varint_field(5, encode_shape(&layer.shape, cache));	×
UNCOV 113	if let Some(ref m_shape) = layer.m_shape {	×
UNCOV 114	pbf.write_varint_field(6, encode_shape(m_shape, cache));	×
UNCOV 115	}	×
116
117	// sort by feature type
UNCOV 118	layer.features.sort_by_key(\|a\| a.get_type());	×
119
UNCOV 120	for feature in &layer.features {	×
UNCOV 121	pbf.write_bytes_field(	×
UNCOV 122	4,	×
UNCOV 123	&write_feature(feature, &layer.shape, layer.m_shape.as_ref(), cache),	×
UNCOV 124	);	×
UNCOV 125	}	×
126
UNCOV 127	pbf.take()	×
UNCOV 128	}	×

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

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