utiles 0.8.0

Web map tile utils (aka utiles)
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
67
68
69
70
71
72
73

use utiles_core::{BBox, ZoomOrZooms, ZoomSet, tile_ranges};

use crate::errors::UtilesResult;

#[derive(Debug, Clone)]
pub struct TilesFilter {
    pub bboxes: Option<Vec<BBox>>,
    pub zooms: Option<Vec<u8>>,
}

impl TilesFilter {
    #[must_use]
    pub fn new(bboxes: Option<Vec<BBox>>, zooms: Option<Vec<u8>>) -> Self {
        Self { bboxes, zooms }
    }

    pub fn mbtiles_sql_where(&self, prefix: Option<&str>) -> UtilesResult<String> {
        self.where_clause(prefix)
    }

    pub fn where_clause(&self, prefix: Option<&str>) -> UtilesResult<String> {
        let pred = match (&self.bboxes, &self.zooms) {
            (Some(bbox), Some(zooms)) => {
                let zboxes = bbox
                    .iter()
                    .flat_map(|b| {
                        tile_ranges(b.tuple(), ZoomOrZooms::Zooms(zooms.clone()))
                    })
                    .collect::<Vec<_>>();
                let pred = zboxes
                    .iter()
                    .map(|a| a.mbtiles_sql_where(prefix))
                    .collect::<Vec<_>>()
                    .join(" OR ");
                format!("({pred})")
            }
            (Some(bbox), None) => {
                let zboxes = bbox
                    .iter()
                    .flat_map(|b| {
                        tile_ranges(
                            b.tuple(),
                            ZoomOrZooms::Zooms(ZoomSet::all().into()),
                        )
                    })
                    .collect::<Vec<_>>();
                let pred = zboxes
                    .iter()
                    .map(|a| a.mbtiles_sql_where(prefix))
                    .collect::<Vec<_>>()
                    .join(" OR ");
                format!("({pred})")
            }
            (None, Some(zooms)) => {
                format!(
                    "zoom_level IN ({zooms})",
                    zooms = zooms
                        .iter()
                        .map(ToString::to_string)
                        .collect::<Vec<String>>()
                        .join(",")
                )
            }
            (None, None) => String::new(),
        };
        // attach 'WHERE'
        if pred.is_empty() {
            Ok(pred)
        } else {
            Ok(format!("WHERE {pred}"))
        }
    }
}