graph-api-simplegraph 0.2.2

A simple, efficient graph implementation for the graph-api ecosystem with support for indexing
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

use std::ops::Range;

pub(crate) enum RangeOrNoneIterator<T, Incr> {
    None {
        exhausted: bool,
    },
    Range {
        current: T,
        range: Range<T>,
        incr: Incr,
    },
}

impl<T, Incr> RangeOrNoneIterator<T, Incr>
where
    T: Copy,
    Incr: Fn(T) -> T,
{
    pub(crate) fn new(range: Option<Range<T>>, incr: Incr) -> RangeOrNoneIterator<T, Incr> {
        match range {
            None => RangeOrNoneIterator::None { exhausted: false },
            Some(r) => RangeOrNoneIterator::Range {
                current: r.start,
                range: r,
                incr,
            },
        }
    }
}

impl<T, Incr> Iterator for RangeOrNoneIterator<T, Incr>
where
    T: Copy + Clone + Ord,
    Incr: Fn(T) -> T,
{
    type Item = Option<T>;

    fn next(&mut self) -> Option<Self::Item> {
        match self {
            RangeOrNoneIterator::None { exhausted } => {
                if *exhausted {
                    None
                } else {
                    *exhausted = true;
                    Some(None)
                }
            }
            RangeOrNoneIterator::Range {
                current,
                range,
                incr,
            } => {
                if *current < range.end {
                    let current_copy = *current;
                    *current = incr(current_copy);
                    Some(Some(current_copy))
                } else {
                    None
                }
            }
        }
    }
}