wireless 0.2.2

Library for dealing with wireless (i.e. GSM, UMTS and LTE) cell identities.
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

extern crate wireless;

mod json;
mod stdin;

use self::wireless::{Countries, Country, LTECell, LTECells, Network, Networks};

pub struct Data {
    pub countries: Countries,
    pub lte_cells: LTECells,
    pub networks: Networks,
}

impl Data {
    pub fn add_country(&mut self) {
        let mcc = match stdin::read_u16("MCC: ", None) {
            Some(a) => a,
            None => return,
        };
        let name = match stdin::read_string("Name: ", None) {
            Some(a) => a,
            None => return,
        };
        let country = Country { mcc: mcc, name: name };
        self.countries.insert(country.mcc, country);
    }
    pub fn add_lte_cell(&mut self) {
        let mcc = match stdin::read_u16("MCC: ", None) {
            Some(a) => a,
            None => return,
        };
        let mnc = match stdin::read_u16("MNC: ", None) {
            Some(a) => a,
            None => return,
        };
        let id = match stdin::read_u32("CID: ", None) {
            Some(a) => a,
            None => return,
        };
        let cell = LTECell { mcc: mcc, mnc: mnc, id: id };
        if self.lte_cells.contains_key(&cell.global_id()) {
            println!("Duplicate cell in database.");
        }
        self.lte_cells.insert(cell.global_id(), cell);
    }
    pub fn add_network(&mut self) {
        let mcc = match stdin::read_u16("MCC: ", None) {
            Some(a) => a,
            None => return,
        };
        let mnc = match stdin::read_u16("MNC: ", None) {
            Some(a) => a,
            None => return,
        };
        let name = match stdin::read_string("Name: ", None) {
            Some(a) => a,
            None => return,
        };
        let network = Network { mcc: mcc, mnc: mnc, name: name };
        self.networks.insert(network.id(), network);
    }
    pub fn print_countries(&self) {
        for country in self.countries.values() {
            println!("#{}: {}", country.mcc, country.name);
        }
    }
    pub fn print_lte_cells(&self) {
        for lte_cell in self.lte_cells.values() {
            println!("#{}-{}-{}", lte_cell.mcc, lte_cell.mnc, lte_cell.id);
        }
    }
    pub fn print_networks(&self) {
        for network in self.networks.values() {
            if network.mnc % 10 == 0 {
                println!("#{}-{:02}: {}", network.mcc, network.mnc / 10, network.name);
            } else {
                println!("#{}-{:03}: {}", network.mcc, network.mnc, network.name);
            }
        }
    }
    pub fn read() -> Data { json::read() }
    pub fn write(&self) { json::write(self); }
}