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
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

extern crate serde;
extern crate serde_json;
extern crate wireless;

use self::serde::ser::Serialize;
use self::wireless::*;
use super::Data;
use std::error::Error;
use std::fs::File;
use std::io::{BufReader, BufWriter};

pub fn read() -> Data {
    let countries = match read_countries() {
        Ok(a) => {
            println!("{} countries read.", a.len());
            a
        }
        Err(e) => {
            println!("Error reading countries data: {}.", e);
            println!("Starting with empty set of countries.");
            Countries::new()
        }
    };
    let lte_cells = match read_lte_cells() {
        Ok(a) => {
            println!("{} LTE cells read.", a.len());
            a
        }
        Err(e) => {
            println!("Error reading LTE cells data: {}.", e);
            println!("Starting with empty set of LTE cells.");
            LTECells::new()
        }
    };
    let networks = match read_networks() {
        Ok(a) => {
            println!("{} networks read.", a.len());
            a
        }
        Err(e) => {
            println!("Error reading networks data: {}.", e);
            println!("Starting with empty set of networks.");
            Networks::new()
        }
    };
    Data { countries: countries, lte_cells: lte_cells, networks: networks }
}

pub fn write(data: &Data) {
    write_json("countries.json", &data.countries);
    write_json("lte_cells.json", &data.lte_cells);
    write_json("networks.json", &data.networks);
}

fn read_countries() -> Result<Countries, String> {
    let file = match File::open("countries.json") {
        Ok(a) => a,
        Err(e) => return Err(e.description().to_string()),
    };
    let reader = BufReader::new(file);
    match serde_json::from_reader(reader) {
        Ok(a) => return Ok(a),
        Err(e) => return Err(e.description().to_string()),
    };
}

fn read_lte_cells() -> Result<LTECells, String> {
    let file = match File::open("lte_cells.json") {
        Ok(a) => a,
        Err(e) => return Err(e.description().to_string()),
    };
    let reader = BufReader::new(file);
    match serde_json::from_reader(reader) {
        Ok(a) => return Ok(a),
        Err(e) => return Err(e.description().to_string()),
    };
}

fn read_networks() -> Result<Networks, String> {
    let file = match File::open("networks.json") {
        Ok(a) => a,
        Err(e) => return Err(e.description().to_string()),
    };
    let reader = BufReader::new(file);
    match serde_json::from_reader(reader) {
        Ok(a) => return Ok(a),
        Err(e) => return Err(e.description().to_string()),
    };
}

fn write_json<T: ?Sized>(file: &str, value: &T)
    where T: Serialize
{
    let file = match File::create(file) {
        Ok(a) => a,
        Err(e) => {
            println!("Error: {}", e.description());
            return;
        }
    };
    let writer = BufWriter::new(file);
    match serde_json::to_writer(writer, value) {
        Ok(_) => return,
        Err(e) => {
            println!("Error: {}", e.description());
            return;
        }
    }
}