openstreetmap-api 0.3.1

Rust client for the OpenstreetMap API.
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

use crate::types;
use crate::Openstreetmap;
use crate::OpenstreetmapError;
use crate::RequestOptions;

#[derive(Debug, Deserialize)]
struct Osm {
    pub api: Api,
    pub policy: types::Policy,
}

impl From<Osm> for types::CapabilitiesAndPolicy {
    fn from(value: Osm) -> types::CapabilitiesAndPolicy {
        types::CapabilitiesAndPolicy {
            capabilities: types::Capabilities {
                versions: types::VersionRange {
                    minimum: value.api.version.minimum,
                    maximum: value.api.version.maximum,
                },
                maximum_area: value.api.area.maximum,
                maximum_note_area: value.api.note_area.maximum,
                tracepoints_per_page: value.api.tracepoints.per_page,
                maximum_waynodes: value.api.waynodes.maximum,
                maximum_changeset_elements: value.api.changesets.maximum_elements,
                timeout: value.api.timeout.seconds,
                status: types::Status {
                    database: value.api.status.database,
                    api: value.api.status.api,
                    gpx: value.api.status.gpx,
                },
            },
            policy: value.policy,
        }
    }
}

#[derive(Debug, Deserialize)]
struct Api {
    pub version: Version,
    pub area: Area,
    pub note_area: NoteArea,
    pub tracepoints: Tracepoints,
    pub waynodes: Waynodes,
    pub changesets: Changesets,
    pub timeout: Timeout,
    pub status: types::Status,
}

#[derive(Debug, Deserialize)]
struct Version {
    pub minimum: String,
    pub maximum: String,
}

#[derive(Debug, Deserialize)]
struct Area {
    pub maximum: f64,
}

#[derive(Debug, Deserialize)]
struct NoteArea {
    pub maximum: f64,
}

#[derive(Debug, Deserialize)]
struct Tracepoints {
    pub per_page: u64,
}

#[derive(Debug, Deserialize)]
struct Waynodes {
    pub maximum: u64,
}

#[derive(Debug, Deserialize)]
struct Changesets {
    pub maximum_elements: u64,
}

#[derive(Debug, Deserialize)]
struct Timeout {
    pub seconds: u64,
}

pub struct Capabilities {
    client: Openstreetmap,
}

impl Capabilities {
    pub fn new(client: &Openstreetmap) -> Self {
        Capabilities {
            client: client.clone(),
        }
    }

    pub async fn get(&self) -> Result<types::CapabilitiesAndPolicy, OpenstreetmapError> {
        let capabilities_and_policies: types::CapabilitiesAndPolicy = self
            .client
            .request::<(), Osm>(
                reqwest::Method::GET,
                "capabilities",
                types::RequestBody::None,
                RequestOptions::new(),
            )
            .await?
            .into();

        Ok(capabilities_and_policies)
    }
}