mlt-core 0.12.4

MapLibre Tile library code
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//! Shared helpers for unit tests, integration tests, and benchmarks.

use std::collections::{BTreeMap, BTreeSet};

use crate::decoder::Layer01;
use crate::{Decoder, Layer, MltRefResult, Parser, PropValue, TileLayer};

/// Default decoder for decoding in tests.
#[must_use]
pub fn dec() -> Decoder {
    Decoder::default()
}

/// Default parser for parsing in tests.
#[must_use]
pub fn parser() -> Parser {
    Parser::default()
}

pub fn assert_empty<T>(result: MltRefResult<T>) -> T {
    let (remaining, value) = result.unwrap();
    assert!(remaining.is_empty(), "{} bytes remain", remaining.len());
    value
}

#[must_use]
pub fn into_layer01(layer: Layer) -> Layer01 {
    match layer {
        Layer::Tag01(v) => v,
        Layer::Unknown(v) => panic!("expected Tag01 layer, got Tag{:02x}", v.tag),
    }
}

/// Map a feature's properties by name. Property column order in [`TileLayer`]
/// can change after MVT normalization, so callers comparing two layers must
/// compare per-feature maps rather than parallel `Vec`s.
#[must_use]
pub fn feature_property_map(layer: &TileLayer, feat_idx: usize) -> BTreeMap<&str, &PropValue> {
    layer
        .property_names()
        .iter()
        .map(String::as_str)
        .zip(layer.features()[feat_idx].properties().iter())
        .collect()
}

/// Assert two layers are semantically equivalent after an MVT round-trip:
/// same name, extent, feature count, ids, geometries, and per-feature property
/// maps (compared by name, not column index).
pub fn assert_mvt_equivalent_layers(a: &TileLayer, b: &TileLayer) {
    assert_eq!(a.name(), b.name(), "layer name");
    assert_eq!(a.extent(), b.extent(), "layer extent");
    let names_a: BTreeSet<&str> = a.property_names().iter().map(String::as_str).collect();
    let names_b: BTreeSet<&str> = b.property_names().iter().map(String::as_str).collect();
    assert_eq!(names_a, names_b, "property name set");
    assert_eq!(a.features().len(), b.features().len(), "feature count");
    for (i, (af, bf)) in a.features().iter().zip(b.features().iter()).enumerate() {
        assert_eq!(af.id(), bf.id(), "feature id (index {i})");
        assert_eq!(af.geometry(), bf.geometry(), "feature geometry (index {i})");
        assert_eq!(
            feature_property_map(a, i),
            feature_property_map(b, i),
            "feature properties (index {i})"
        );
    }
}