geolite 0.0.18

open source geocode solution
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

use std::fmt;

use crate::admin_level::id::{admin_level_id, osm_element_kind};

const SEPARATOR: char = '.';
const HOUSE_NUMBER_MARK: &str = ".n";

pub struct address_id {
  pub iso: String,
  pub leaf: i64,
  pub path: Vec<i64>,
  pub house_number: Option<String>,
}

impl address_id {
  pub fn encode(iso: &str, leaf: i64, path: &[i64], house_number: Option<&str>) -> String {
    let mut encoded = String::with_capacity(3 + (path.len() + 1) * 12);
    encoded.push_str(&iso.to_ascii_lowercase());
    for id in path.iter().rev().chain(std::iter::once(&leaf)) {
      encoded.push(SEPARATOR);
      push_element(&mut encoded, *id);
    }
    if let Some(number) = house_number {
      encoded.push_str(HOUSE_NUMBER_MARK);
      encoded.push_str(number);
    }
    encoded
  }

  pub fn parse(raw: &str) -> Option<Self> {
    let lowered = raw.trim().to_ascii_lowercase();
    let (elements, house_number) = match lowered.split_once(HOUSE_NUMBER_MARK) {
      Some((_, "")) => return None,
      Some((elements, number)) => (elements, Some(number.to_string())),
      None => (lowered.as_str(), None),
    };
    let mut segments = elements.split(SEPARATOR);
    let iso = segments.next()?;
    if iso.len() != 2 || !iso.bytes().all(|b| b.is_ascii_lowercase()) {
      return None;
    }
    let mut ids: Vec<i64> = Vec::new();
    for segment in segments {
      ids.push(parse_element(segment)?);
    }
    let leaf = ids.pop()?;
    ids.reverse();
    Some(address_id {
      iso: iso.to_string(),
      leaf,
      path: ids,
      house_number,
    })
  }
}

impl fmt::Display for address_id {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    f.write_str(&Self::encode(
      &self.iso,
      self.leaf,
      &self.path,
      self.house_number.as_deref(),
    ))
  }
}

fn push_element(encoded: &mut String, id: i64) {
  let element = admin_level_id::from_raw(id as u64);
  encoded.push(match element.kind() {
    osm_element_kind::relation => 'r',
    osm_element_kind::way => 'w',
  });
  encoded.push_str(&element.osm_id().to_string());
}

fn parse_element(segment: &str) -> Option<i64> {
  let element_of: fn(u64) -> admin_level_id = match segment.as_bytes().first()? {
    b'r' => admin_level_id::from_relation,
    b'w' => admin_level_id::from_way,
    _ => return None,
  };
  let digits = &segment[1..];
  if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
    return None;
  }
  let osm_id: u64 = digits.parse().ok()?;
  if osm_id >> 62 != 0 {
    return None;
  }
  Some(element_of(osm_id).raw() as i64)
}