geolite 0.0.2

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
110
111
112
113
114
115
116
117
118
119
120

use prost::Message;
use std::{
  fs,
  io::{Read, Seek},
};

#[derive(prost::Message)]
struct header_block_msg {
  #[prost(message, optional, tag = "1")]
  bbox: Option<header_bbox_msg>,
  #[prost(string, repeated, tag = "4")]
  required_features: Vec<String>,
  #[prost(string, repeated, tag = "5")]
  optional_features: Vec<String>,
  #[prost(string, optional, tag = "16")]
  writingprogram: Option<String>,
  #[prost(string, optional, tag = "17")]
  source: Option<String>,
  #[prost(int64, optional, tag = "32")]
  osmosis_replication_timestamp: Option<i64>,
  #[prost(int64, optional, tag = "33")]
  osmosis_replication_sequence_number: Option<i64>,
  #[prost(string, optional, tag = "34")]
  osmosis_replication_base_url: Option<String>,
}

#[derive(prost::Message)]
struct header_bbox_msg {
  #[prost(sint64, tag = "1")]
  left: i64,
  #[prost(sint64, tag = "2")]
  right: i64,
  #[prost(sint64, tag = "3")]
  top: i64,
  #[prost(sint64, tag = "4")]
  bottom: i64,
}

pub struct header_bbox {
  pub bottom: f64,
  pub left: f64,
  pub top: f64,
  pub right: f64,
}

pub struct header_output {
  pub bbox: Option<header_bbox>,
  pub writingprogram: Option<String>,
  pub source: Option<String>,
  pub replication_timestamp: Option<i64>,
}

pub fn run(pbf: &str, conn: &rusqlite::Connection, file_id: u32) -> header_output {
  let chunk = crate::database::osm_pbf_blob_chunks::get_header_chunk(conn, file_id)
    .expect("no header chunk found in sqlite — run extract osm-pbf-blob-chunks first");

  let mut file = fs::File::open(pbf).expect("failed to open pbf file");
  file
    .seek(std::io::SeekFrom::Start(chunk.data_first_byte))
    .expect("failed to seek to header blob");

  let mut blob_buf = vec![0u8; chunk.data_size as usize];
  file
    .read_exact(&mut blob_buf)
    .expect("failed to read header blob");

  let blob = super::osm_data::blob_msg::decode(blob_buf.as_slice()).expect("failed to decode blob");
  let raw = super::decompress_blob(&blob);

  let h = header_block_msg::decode(raw.as_slice()).expect("failed to decode header block");

  const NANO: f64 = 1e-9;

  let bbox_wkt = h.bbox.as_ref().map(|b| {
    let left = b.left as f64 * NANO;
    let right = b.right as f64 * NANO;
    let top = b.top as f64 * NANO;
    let bot = b.bottom as f64 * NANO;
    format!("POLYGON(({left} {bot},{right} {bot},{right} {top},{left} {top},{left} {bot}))")
      .into_bytes()
  });

  let required_features = if h.required_features.is_empty() {
    None
  } else {
    Some(serde_json::to_vec(&h.required_features).expect("failed to serialize required_features"))
  };

  let optional_features = if h.optional_features.is_empty() {
    None
  } else {
    Some(serde_json::to_vec(&h.optional_features).expect("failed to serialize optional_features"))
  };

  crate::database::osm_pbf_files::update_osm_header(
    conn,
    pbf,
    bbox_wkt,
    required_features,
    optional_features,
    h.writingprogram.as_deref(),
    h.source.as_deref(),
    h.osmosis_replication_timestamp,
    h.osmosis_replication_sequence_number
      .and_then(|v| u32::try_from(v).ok()),
    h.osmosis_replication_base_url.as_deref(),
  );

  header_output {
    bbox: h.bbox.map(|b| header_bbox {
      bottom: b.bottom as f64 * NANO,
      left: b.left as f64 * NANO,
      top: b.top as f64 * NANO,
      right: b.right as f64 * NANO,
    }),
    writingprogram: h.writingprogram,
    source: h.source,
    replication_timestamp: h.osmosis_replication_timestamp,
  }
}