ip2location-iso3166-2 0.4.0

IP2Location™ ISO 3166-2 Subdivision Code
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

use core::ops::Deref;
use std::io::Read;

use csv::{Error as CsvError, Reader, StringRecord};

use crate::record::Record;

//
#[cfg(feature = "once_cell")]
pub static RECORDS: once_cell::sync::Lazy<Records> = once_cell::sync::Lazy::new(|| {
    let csv = include_str!("../data/IP2LOCATION-ISO3166-2.CSV");
    Records::from_csv(csv.as_bytes()).unwrap()
});

#[cfg(feature = "once_cell")]
pub static RECORDS_CODE_MAP: once_cell::sync::Lazy<
    std::collections::HashMap<country_code::iso3166_2::SubdivisionCode, Record>,
> = once_cell::sync::Lazy::new(|| {
    RECORDS
        .iter()
        .cloned()
        .map(|x| (x.code.to_owned(), x))
        .collect()
});

//
#[derive(Debug, Clone)]
pub struct Records(pub Vec<Record>);

impl Deref for Records {
    type Target = Vec<Record>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

//
impl Records {
    pub fn from_csv<R: Read>(rdr: R) -> Result<Self, RecordsFromCsvError> {
        let mut rdr = Reader::from_reader(rdr);

        let mut inner = vec![];

        for record in rdr.records() {
            let record = record.map_err(RecordsFromCsvError::CsvParseFailed)?;

            /*
            LINE: "AI","Anguilla","-"
            */
            let record = if record.get(2) == Some("-") {
                StringRecord::from(vec![
                    &record[0],
                    &record[1],
                    format!("{}-", &record[0]).as_str(),
                ])
            } else {
                record
            };

            let row: Record = record
                .deserialize(None)
                .map_err(RecordsFromCsvError::RecordDeFailed)?;
            inner.push(row);
        }

        Ok(Self(inner))
    }
}

//
#[derive(Debug)]
pub enum RecordsFromCsvError {
    CsvParseFailed(CsvError),
    RecordDeFailed(CsvError),
}

impl core::fmt::Display for RecordsFromCsvError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{self:?}")
    }
}

impl std::error::Error for RecordsFromCsvError {}