osmgraphing 1.1.1

Playing around with graphs created via parsing OpenStreetMap data
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::{
    cmp::Ord,
    fmt::{self, Display},
    ops::{Deref, DerefMut, Range},
};

//------------------------------------------------------------------------------------------------//

#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeIdx(pub usize);

impl Display for NodeIdx {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl Deref for NodeIdx {
    type Target = usize;

    fn deref(&self) -> &usize {
        &self.0
    }
}

impl DerefMut for NodeIdx {
    fn deref_mut(&mut self) -> &mut usize {
        &mut self.0
    }
}

pub struct NodeIdxIterator {
    range: Range<usize>,
}

impl Iterator for NodeIdxIterator {
    type Item = NodeIdx;

    fn next(&mut self) -> Option<NodeIdx> {
        Some(NodeIdx(self.range.next()?))
    }
}

impl From<Range<NodeIdx>> for NodeIdxIterator {
    fn from(range: Range<NodeIdx>) -> NodeIdxIterator {
        NodeIdxIterator {
            range: range.start.0..range.end.0,
        }
    }
}

impl From<Range<usize>> for NodeIdxIterator {
    fn from(range: Range<usize>) -> NodeIdxIterator {
        NodeIdxIterator { range }
    }
}

//------------------------------------------------------------------------------------------------//

#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EdgeIdx(pub usize);

impl Display for EdgeIdx {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl Deref for EdgeIdx {
    type Target = usize;

    fn deref(&self) -> &usize {
        &self.0
    }
}

impl DerefMut for EdgeIdx {
    fn deref_mut(&mut self) -> &mut usize {
        &mut self.0
    }
}

pub struct EdgeIdxIterator {
    range: Range<usize>,
}

impl Iterator for EdgeIdxIterator {
    type Item = EdgeIdx;

    fn next(&mut self) -> Option<EdgeIdx> {
        Some(EdgeIdx(self.range.next()?))
    }
}

impl From<Range<EdgeIdx>> for EdgeIdxIterator {
    fn from(range: Range<EdgeIdx>) -> EdgeIdxIterator {
        EdgeIdxIterator {
            range: range.start.0..range.end.0,
        }
    }
}

impl From<Range<usize>> for EdgeIdxIterator {
    fn from(range: Range<usize>) -> EdgeIdxIterator {
        EdgeIdxIterator { range }
    }
}

//------------------------------------------------------------------------------------------------//

#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MetricIdx(pub usize);

impl Display for MetricIdx {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl Deref for MetricIdx {
    type Target = usize;

    fn deref(&self) -> &usize {
        &self.0
    }
}

impl DerefMut for MetricIdx {
    fn deref_mut(&mut self) -> &mut usize {
        &mut self.0
    }
}