opencellid 0.2.0

Rust client library for the OpenCellID API — sync and async clients with tracing, structured errors, and bounded I/O.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Strongly-typed query parameters for endpoints.

use crate::types::{Bbox, Lac, Mcc, Mnc, Radio};

/// Parameters for `cell/getInArea` and `cell/getInAreaSize`.
///
/// `bbox` is required; everything else narrows the query.
#[derive(Debug, Clone)]
pub struct AreaQuery {
    /// Bounding box to search within.
    pub bbox: Bbox,
    /// Restrict to a specific country.
    pub mcc: Option<Mcc>,
    /// Restrict to a specific network operator.
    pub mnc: Option<Mnc>,
    /// Restrict to a specific location area.
    pub lac: Option<Lac>,
    /// Restrict to a specific radio technology.
    pub radio: Option<Radio>,
}

impl AreaQuery {
    /// Start a query for cells inside `bbox` with no other filters.
    pub fn new(bbox: Bbox) -> Self {
        Self { bbox, mcc: None, mnc: None, lac: None, radio: None }
    }

    /// Restrict to a specific MCC.
    pub fn mcc(mut self, mcc: Mcc) -> Self {
        self.mcc = Some(mcc);
        self
    }

    /// Restrict to a specific MNC.
    pub fn mnc(mut self, mnc: Mnc) -> Self {
        self.mnc = Some(mnc);
        self
    }

    /// Restrict to a specific LAC.
    pub fn lac(mut self, lac: Lac) -> Self {
        self.lac = Some(lac);
        self
    }

    /// Restrict to a specific radio technology.
    pub fn radio(mut self, radio: Radio) -> Self {
        self.radio = Some(radio);
        self
    }
}

/// Parameters for `cell/getInArea` — adds pagination on top of [`AreaQuery`].
///
/// Default response format on the wire is CSV (parsed into [`crate::Cell`] values).
#[derive(Debug, Clone)]
pub struct GetCellsInAreaParams {
    /// Geographic and operator filters.
    pub query: AreaQuery,
    /// Maximum cells to return per call. Server caps at 50.
    pub limit: Option<u32>,
    /// Pagination offset.
    pub offset: Option<u32>,
}

impl GetCellsInAreaParams {
    /// Start parameters for the given query.
    pub fn new(query: AreaQuery) -> Self {
        Self { query, limit: None, offset: None }
    }

    /// Set page size (server caps at 50).
    pub fn limit(mut self, limit: u32) -> Self {
        self.limit = Some(limit);
        self
    }

    /// Set pagination offset.
    pub fn offset(mut self, offset: u32) -> Self {
        self.offset = Some(offset);
        self
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::Bbox;

    fn bbox() -> Bbox {
        Bbox::new(0.0, 0.0, 1.0, 1.0).unwrap()
    }

    #[test]
    fn area_query_setters_cover_all_fields() {
        let q = AreaQuery::new(bbox()).mcc(250).mnc(1).lac(7800).radio(crate::types::Radio::Lte);
        assert_eq!(q.mcc, Some(250));
        assert_eq!(q.mnc, Some(1));
        assert_eq!(q.lac, Some(7800));
        assert_eq!(q.radio, Some(crate::types::Radio::Lte));
    }

    #[test]
    fn area_query_last_setter_wins() {
        let q = AreaQuery::new(bbox()).mcc(1).mcc(2);
        assert_eq!(q.mcc, Some(2));
    }

    #[test]
    fn get_cells_in_area_params_pagination() {
        let p = GetCellsInAreaParams::new(AreaQuery::new(bbox()))
            .limit(50)
            .offset(100);
        assert_eq!(p.limit, Some(50));
        assert_eq!(p.offset, Some(100));
    }
}