///|
/// Extent used when a layer does not declare one.
const DEFAULT_EXTENT : Int32 = 4096
///|
/// A feature's geometry type, as the MVT spec numbers them from 0 (§4.3.4).
#derive(Debug, Eq)
pub(all) enum GeomType {
Unknown
Point
LineString
Polygon
}
///|
/// A decoded tile. Layer tables, feature headers and tags are decoded and
/// validated by `Tile::parse`; feature geometry stays encoded until requested.
pub struct Tile {
layers : Array[Layer]
}
///|
/// A tile layer; `keys` and `values` are the tables feature tags index into.
/// Features are addressed by index in `0.. TagCheck {
{ max_key: -1, max_key_pos: 0, max_value: -1, max_value_pos: 0, odd_pos: -1, }
}
///|
fn TagCheck::record(
self : TagCheck,
k : Int32,
kpos : Int32,
v : Int32,
vpos : Int32,
) -> Unit {
if k > self.max_key {
self.max_key = k
self.max_key_pos = kpos
}
if v > self.max_value {
self.max_value = v
self.max_value_pos = vpos
}
}
///|
fn TagCheck::verify(self : TagCheck, layer : Layer) -> Unit raise MvtError {
if self.odd_pos >= 0 {
raise OddTagCount(pos=self.odd_pos)
}
if self.max_key >= layer.keys.length() {
raise IndexOutOfRange(pos=self.max_key_pos, self.max_key)
}
if self.max_value >= layer.values.length() {
raise IndexOutOfRange(pos=self.max_value_pos, self.max_value)
}
}
///|
pub fn Tile::parse(bytes : BytesView) -> Tile raise MvtError {
let r = @pbf.Reader::new(bytes)
let layers = []
while !r.at_end() {
let t = r.read_tag()
if t == TILE_LAYER {
let check = TagCheck::new()
let layer = parse_layer(r, @pbf.Reader::new(bytes), check)
if r.failed() {
break
}
check.verify(layer)
layers.push(layer)
} else {
r.skip(t)
}
}
if r.error() is Some(e) {
raise Malformed(e)
}
{ layers, }
}
///|
fn parse_layer(
r : @pbf.Reader,
cursor : @pbf.Reader,
check : TagCheck,
) -> Layer {
let token = r.enter()
let mut name = ""
let mut version = 1
let mut extent = DEFAULT_EXTENT
let keys = []
let values = []
let ids = []
let types = []
let geoms = []
let tags = []
let tag_offsets = [0]
while !r.at_end() {
let t = r.read_tag()
match t {
LAYER_VERSION => version = r.read_varint32()
LAYER_NAME => name = r.read_string()
LAYER_FEATURE =>
parse_feature_header(r, ids, types, geoms, tags, tag_offsets, check)
LAYER_KEY => keys.push(r.read_string())
LAYER_VALUE => values.push(parse_value(r))
// Everything downstream divides by it.
LAYER_EXTENT =>
extent = match r.read_varint32() {
e if e > 0 => e
_ => DEFAULT_EXTENT
}
_ => r.skip(t)
}
}
r.exit(token)
{
name,
version,
extent,
keys,
values,
ids,
types,
geoms,
tags,
tag_offsets,
cursor,
}
}
///|
fn parse_feature_header(
r : @pbf.Reader,
ids : Array[UInt64],
types : Array[Int32],
geoms : Array[Int32],
tags : Array[Int32],
tag_offsets : Array[Int32],
check : TagCheck,
) -> Unit {
let token = r.enter()
let mut id = 0UL
let mut flags = 0
let mut geom_start = 0
let mut geom_end = 0
while !r.at_end() {
let t = r.read_tag()
match t {
FEATURE_ID => {
id = r.read_varint64()
flags = flags | HAS_ID
}
FEATURE_TAGS => decode_tags(r, tags, check)
FEATURE_TYPE => {
let ty = r.read_varint32()
let known = ty == GEOM_POINT ||
ty == GEOM_LINESTRING ||
ty == GEOM_POLYGON
flags = (flags & HAS_ID) | (if known { ty } else { 0 })
}
FEATURE_GEOMETRY => {
geom_start = r.read_len_start()
geom_end = r.pos()
}
_ => r.skip(t)
}
}
r.exit(token)
ids.push(id)
types.push(flags)
geoms.push(geom_start)
geoms.push(geom_end)
tag_offsets.push(tags.length())
}
///|
/// Appends a packed tag field's (key, value) index pairs to `tags`.
fn decode_tags(r : @pbf.Reader, tags : Array[Int32], check : TagCheck) -> Unit {
let token = r.enter()
while !r.at_end() {
let kpos = r.pos()
let k = r.read_varint32()
if r.at_end() {
if !r.failed() && check.odd_pos < 0 {
check.odd_pos = kpos
}
break
}
let vpos = r.pos()
let v = r.read_varint32()
// Indices are uint32; anything that reads back negative is out of range.
let k = if k < 0 { @int.MAX_VALUE } else { k }
let v = if v < 0 { @int.MAX_VALUE } else { v }
check.record(k, kpos, v, vpos)
tags.push(k)
tags.push(v)
}
r.exit(token)
}
///|
/// The last layer called `name`, as other decoders resolve duplicates.
pub fn Tile::layer(self : Tile, name : String) -> Layer? {
for i = self.layers.length() - 1; i >= 0; i = i - 1 {
if self.layers[i].name == name {
return Some(self.layers[i])
}
}
None
}
///|
pub fn Layer::length(self : Layer) -> Int32 {
self.types.length()
}
///|
pub fn Layer::geom_type(self : Layer, i : Int32) -> GeomType {
match self.types[i] & GEOM_MASK {
GEOM_POINT => Point
GEOM_LINESTRING => LineString
GEOM_POLYGON => Polygon
_ => Unknown
}
}
///|
pub fn Layer::id(self : Layer, i : Int32) -> UInt64? {
if (self.types[i] & HAS_ID) != 0 {
Some(self.ids[i])
} else {
None
}
}
///|
/// Index of `key` in `keys`, for `property`; resolve it once per layer.
pub fn Layer::key_index(self : Layer, key : String) -> Int32? {
for i, k in self.keys {
if k == key {
return Some(i)
}
}
None
}
///|
/// Feature `i`'s value for the key at `key_index`, without allocating.
/// A repeated key yields its last value.
pub fn Layer::property(self : Layer, i : Int32, key_index : Int32) -> Value? {
let mut found = -1
for t = self.tag_offsets[i]; t < self.tag_offsets[i + 1]; t = t + 2 {
if self.tags[t] == key_index {
found = self.tags[t + 1]
}
}
if found < 0 {
None
} else {
Some(self.values[found])
}
}
///|
/// How many tags (key and value pairs) feature `i` has.
pub fn Layer::tag_count(self : Layer, i : Int32) -> Int32 {
(self.tag_offsets[i + 1] - self.tag_offsets[i]) / 2
}
///|
/// Feature `i`'s tag `k` (0 <= `k` < `tag_count(i)`) as key and value, in
/// the order the tile lists them.
pub fn Layer::tag(self : Layer, i : Int32, k : Int32) -> (String, Value) {
let t = self.tag_offsets[i] + k * 2
(self.keys[self.tags[t]], self.values[self.tags[t + 1]])
}
///|
/// Feature `i`'s tags as a key → value map; a repeated key keeps its last value.
pub fn Layer::properties(self : Layer, i : Int32) -> Map[String, Value] {
let start = self.tag_offsets[i]
let end = self.tag_offsets[i + 1]
let props = Map([], capacity=(end - start) / 2)
for t = start; t < end; t = t + 2 {
props[self.keys[self.tags[t]]] = self.values[self.tags[t + 1]]
}
props
}