open-geocode 0.1.0

Lightweight geocoding engine: build a binary Pack from OSM extracts and serve search, autocomplete, and reverse geocoding from a single Rust runtime.
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
110
111

use crate::record::{
    AddressComponents, InterpolationAddressComponents, InterpolationRange, OsmObjectType,
};

pub fn address_name(components: &AddressComponents) -> String {
    [
        Some(components.number.as_str()),
        components.street.as_deref().or(components.place.as_deref()),
    ]
    .into_iter()
    .flatten()
    .collect::<Vec<_>>()
    .join(" ")
}

pub fn address_label(components: &AddressComponents) -> String {
    let primary = address_name(components);
    [
        Some(primary.as_str()),
        components.unit.as_deref(),
        components.locality.as_deref(),
        components.region.as_deref(),
        components.postcode.as_deref(),
        components.country.as_deref(),
    ]
    .into_iter()
    .flatten()
    .filter(|part| !part.is_empty())
    .collect::<Vec<_>>()
    .join(", ")
}

pub fn interpolation_name(components: &InterpolationAddressComponents) -> String {
    components
        .street
        .as_deref()
        .or(components.place.as_deref())
        .unwrap_or("")
        .to_string()
}

pub fn interpolation_label(
    name: &str,
    range: &InterpolationRange,
    components: &InterpolationAddressComponents,
) -> String {
    let primary = format!(
        "{name} {start}-{end} {kind}",
        start = range.start,
        end = range.end,
        kind = range.kind
    );
    [
        Some(primary),
        components.locality.clone(),
        components.region.clone(),
        components.postcode.clone(),
        components.country.clone(),
    ]
    .into_iter()
    .flatten()
    .collect::<Vec<_>>()
    .join(", ")
}

pub fn osm_record_id(object_type: OsmObjectType, object_id: i64) -> String {
    format!("osm:{}:{object_id}", osm_object_type_name(object_type))
}

pub fn derived_postcode_id(postcode: &str) -> String {
    format!("derived:osm:postcode:{}", url_safe_id_component(postcode))
}

pub fn derived_country_id(code: &str) -> String {
    format!("derived:country:{code}")
}

pub fn interpolation_record_id(way_id: i64, low_node_id: i64, high_node_id: i64) -> String {
    format!("osm:way:{way_id}:interp:{low_node_id}-{high_node_id}")
}

pub(crate) fn place_record_id(
    object_type: OsmObjectType,
    object_id: i64,
    place_type: &str,
) -> String {
    match place_type.strip_prefix("derived_country:") {
        Some(code) => derived_country_id(code),
        None => osm_record_id(object_type, object_id),
    }
}

pub fn osm_object_type_name(object_type: OsmObjectType) -> &'static str {
    match object_type {
        OsmObjectType::Node => "node",
        OsmObjectType::Way => "way",
        OsmObjectType::Relation => "relation",
    }
}

fn url_safe_id_component(value: &str) -> String {
    value
        .bytes()
        .flat_map(|byte| match byte {
            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {
                vec![byte as char]
            }
            _ => format!("%{byte:02X}").chars().collect::<Vec<_>>(),
        })
        .collect()
}