Struct VectorTileLayer 

pub struct VectorTileLayer {
    pub extent: u32,
    pub features: Vec<VectorTileFeature>,
    pub name: String,
    pub property_manager: PropertyManager,
    pub version: u32,
}

A single vector‑tile layer with features, key/value property tables, extent, and version.

The layer stores features in compact vector‑tile form. The property_manager maintains the global key and value tables required by the MVT spec; features reference properties by index via tag_ids. Helper methods convert to and from high‑level GeoFeature values for easier processing and GeoJSON export.

Fields

extent: u32

Tile coordinate extent used to quantize geometry (default 4096).

features: Vec<VectorTileFeature>

The layer’s vector‑tile features (geometry + tags).

name: String

Human‑readable layer name (MVT field 1).

property_manager: PropertyManager

Global key/value tables shared by all features in this layer.

version: u32

MVT layer version (default 1).

Implementations

impl VectorTileLayer

pub fn new(name: String, extent: u32, version: u32) -> VectorTileLayer

Creates a new layer with the given name, extent, and version.

Does not add any features; initializes an empty property table.

pub fn new_standard(name: &str) -> VectorTileLayer

Convenience constructor using the common defaults extent = 4096, version = 1.

pub fn read(reader: &mut dyn ValueReader<'_, LE>) -> Result<VectorTileLayer>

Reads a VectorTileLayer from a protobuf stream using the MVT wire format.

Expects the fields as defined by the MVT spec and collects keys/values into the property_manager. Returns an error on malformed inputs.

pub fn to_blob(&self) -> Result<Blob>

Serializes the layer into a protobuf Blob (MVT wire format).

Writes name, features, key/value tables, and non‑default extent/version.

pub fn to_features(&self) -> Result<Vec<GeoFeature>>

Converts all vector‑tile features into high‑level GeoFeatures using this layer’s property tables.

pub fn filter_map_properties<F>(&mut self, filter_fn: F) -> Result<()>

where F: Fn(GeoProperties) -> Option<GeoProperties>,

Filters/mutates features by decoding their properties, applying a filter that may drop the feature, recomputing the global property tables, and re‑encoding tag ids. Returns an error if decoding fails.

pub fn map_properties<F>(&mut self, filter_fn: F) -> Result<()>

where F: Fn(GeoProperties) -> GeoProperties,

Transforms properties of all features (non‑dropping). Decodes properties, maps them, rebuilds the property tables, and re‑encodes tag ids.

pub fn add_vector_tile_features( &mut self, feature: VectorTileFeature, properties: GeoProperties, )

Adds a VectorTileFeature with explicit properties by encoding its tag ids against the current property tables.

pub fn add_from_layer(&mut self, layer: VectorTileLayer) -> Result<()>

Merges another layer’s features into self, decoding their properties with the source layer’s tables and re‑encoding them against this layer’s property_manager.

pub fn retain_features<F>(&mut self, filter_fn: F)

where F: Fn(&VectorTileFeature) -> bool,

Retains only features that satisfy filter_fn (applies to raw VectorTileFeatures).

pub fn encode_tag_ids(&mut self, properties: GeoProperties) -> Vec<u32>

Encodes a property map to vector‑tile tag_ids using/expanding this layer’s property tables.

pub fn decode_tag_ids(&self, tag_ids: &[u32]) -> Result<GeoProperties>

Decodes vector‑tile tag_ids back into a property map using this layer’s property tables.

pub fn from_features( name: String, features: Vec<GeoFeature>, extent: u32, version: u32, ) -> Result<VectorTileLayer>

Builds a layer from high‑level GeoFeatures.

Aggregates all properties into key/value tables and converts geometries into VectorTileFeatures with encoded tag_ids.

Trait Implementations

impl Clone for VectorTileLayer

fn clone(&self) -> VectorTileLayer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VectorTileLayer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for VectorTileLayer

fn default() -> VectorTileLayer

Returns the “default value” for a type.

impl PartialEq for VectorTileLayer

fn eq(&self, other: &VectorTileLayer) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for VectorTileLayer