geolite 0.0.8

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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use rusqlite::Connection;

use super::entity::admin_level;
use super::rules::extraction_rules;
use super::scale::level;
use super::{place_ways, relations, streets};

pub struct extract_opts<'a> {
  pub threads: usize,
  pub name_priority: &'a [&'a str],
  pub rules: &'a [extraction_rules],
}

pub struct progress_report {
  pub total: Option<u64>,
  pub processed: u64,
}

pub(super) const CHUNK_SIZE: usize = 500;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum source {
  relations,
  place_ways,
  streets,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct stage {
  pub level: level,
  pub source: source,
  pub ordinal: usize,
  pub of: usize,
}

pub struct extract_event {
  pub stage: stage,
  pub step: extract_step,
}

pub enum extract_step {
  started,
  candidates { found: u64, pending: u64 },
  progress(progress_report),
  finished,
}

impl admin_level {
  pub fn stages_of(level: level) -> Vec<stage> {
    let sources: &[source] = match level {
      level::neighborhood => &[source::relations, source::place_ways],
      level::street => &[source::streets],
      _ => &[source::relations],
    };
    sources
      .iter()
      .enumerate()
      .map(|(i, &source)| stage {
        level,
        source,
        ordinal: i + 1,
        of: sources.len(),
      })
      .collect()
  }

  pub fn extract(
    conn: &Connection,
    level: level,
    opts: &extract_opts,
    mut on_event: impl FnMut(extract_event),
  ) {
    for stage in Self::stages_of(level) {
      let mut emit = |step: extract_step| on_event(extract_event { stage, step });
      emit(extract_step::started);
      match stage.source {
        source::relations => {
          let found =
            crate::database::osm_relations::all_ids_by_admin_level(conn, level.value()).len() as u64;
          let pending =
            crate::database::osm_relations::remaining_ids_by_admin_level(conn, level.value());
          emit(extract_step::candidates {
            found,
            pending: pending.len() as u64,
          });
          relations::run_with_ids(
            conn,
            pending,
            level,
            opts.threads,
            opts.name_priority,
            |report| emit(extract_step::progress(report)),
          );
        }
        source::place_ways => place_ways::run(conn, opts.rules, opts.name_priority, |report| {
          emit(extract_step::progress(report))
        }),
        source::streets => streets::run(conn, opts.rules, opts.name_priority, |report| {
          emit(extract_step::progress(report))
        }),
      }
      emit(extract_step::finished);
    }
  }
}

#[cfg(test)]
#[path = "extract.test.rs"]
mod tests;