hecate 0.62.0

OpenStreetMap Inspired Data Storage Backend Focused on Performance and GeoJSON Interchange
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use std::fmt;
use std::collections::HashMap;
use osm::*;

pub struct OSMTree {
    pub meta: HashMap<String, String>,
    nodes: HashMap<i64, Node>,
    ways: HashMap<i64, Way>,
    rels: HashMap<i64, Rel>
}

impl OSMTree {
    pub fn new() -> OSMTree {
        OSMTree {
            meta: HashMap::new(),
            nodes: HashMap::new(),
            ways: HashMap::new(),
            rels: HashMap::new()
        }
    }

    pub fn add_node(&mut self, node: Node) -> Result<bool, XMLError> {
        match node.is_valid() {
            Err(err) => { return Err(XMLError::InvalidNode(err)); }
            _ => ()
        }

        self.nodes.insert(node.id.unwrap(), node);
        Ok(true)
    }

    pub fn get_nodes(&self) -> &HashMap<i64, Node> {
        &self.nodes
    }

    pub fn get_nodes_mut(&mut self) -> &mut HashMap<i64, Node> {
        &mut self.nodes
    }

    pub fn get_node_mut(&mut self, id: &i64) -> Result<&mut Node, XMLError> {
        match self.nodes.get_mut(&id) {
            Some(n) => Ok(n),
            None => Err(XMLError::NotFoundError)
        }
    }

    pub fn get_node(&self, id: &i64) -> Result<&Node, XMLError> {
        match self.nodes.get(&id) {
            Some(n) => Ok(n),
            None => Err(XMLError::NotFoundError)
        }
    }

    pub fn add_way(&mut self, way: Way) -> Result<bool, XMLError> {
        match way.is_valid() {
            Err(err) => { return Err(XMLError::InvalidWay(err)); },
            _ => ()
        }

        for nd in &way.nodes {
            //Tree must contain node refs below 0 as these are being created in the same transaction
            if *nd < 0 && !self.nodes.contains_key(&nd) {
                return Err(XMLError::InvalidNodeRef);
            }

            match self.nodes.get_mut(&nd) {
                Some(nd) => nd.parents.push(way.id.unwrap()),
                None => { return Err(XMLError::InternalError(String::from("unable to get node"))) }
            }
        }

        self.ways.insert(way.id.unwrap(), way);
        Ok(true)
    }

    pub fn get_ways(&self) -> &HashMap<i64, Way> {
        &self.ways
    }

    pub fn get_ways_mut(&mut self) -> &mut HashMap<i64, Way> {
        &mut self.ways
    }

    pub fn get_way(&self, id: &i64) -> Result<&Way, XMLError> {
        match self.ways.get(&id) {
            Some(n) => Ok(n),
            None => Err(XMLError::NotFoundError)
        }
    }

    pub fn get_way_mut(&mut self, id: &i64) -> Result<&mut Way, XMLError> {
        match self.ways.get_mut(&id) {
            Some(n) => Ok(n),
            None => Err(XMLError::NotFoundError)
        }
    }

    pub fn add_rel(&mut self, rel: Rel) -> Result<bool, XMLError> {
        match rel.is_valid() {
            Err(err) => { return Err(XMLError::InvalidRel(err)); },
            _ => ()
        }

        self.rels.insert(rel.id.unwrap(), rel);
        Ok(true)
    }

    pub fn get_rels(&self) -> &HashMap<i64, Rel> {
        &self.rels
    }

    pub fn get_rels_mut(&mut self) -> &mut HashMap<i64, Rel> {
        &mut self.rels
    }

    pub fn get_rel(&self, id: &i64) -> Result<&Rel, XMLError> {
        match self.rels.get(&id) {
            Some(n) => Ok(n),
            None => Err(XMLError::NotFoundError)
        }
    }

    pub fn get_rel_mut(&mut self, id: &i64) -> Result<&mut Rel, XMLError> {
        match self.rels.get_mut(&id) {
            Some(n) => Ok(n),
            None => Err(XMLError::NotFoundError)
        }
    }
}

impl fmt::Display for OSMTree {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[OSMTree: nodes={} ways={} rels={}]", self.nodes.len(), self.ways.len(), self.rels.len())
    }
}