dook 0.3.1

Look up definitions in your code
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

#[derive(Default, Debug, Clone)]
pub struct RangeUnion {
    ends_by_start: std::collections::BTreeMap<usize, usize>,
}

impl RangeUnion {
    pub fn push(&mut self, range: impl std::borrow::Borrow<std::ops::Range<usize>>) {
        let range = range.borrow();
        self.ends_by_start
            .entry(range.start)
            .and_modify(|e| *e = (*e).max(range.end))
            .or_insert(range.end);
    }

    pub fn extend(&mut self, ranges: impl IntoIterator<Item = std::ops::Range<usize>>) {
        for range in ranges {
            self.push(range);
        }
    }

    pub fn iter_filling_gaps(&self, gap_size: usize) -> RangeUnionIterator {
        let mut iterator = self.ends_by_start.iter();
        let first_interval = iterator.next();
        RangeUnionIterator {
            position: iterator,
            current_interval: first_interval,
            fill_gaps: gap_size,
        }
    }

    pub fn iter(&self) -> RangeUnionIterator {
        self.iter_filling_gaps(0)
    }

    pub fn is_empty(&self) -> bool {
        self.ends_by_start.is_empty()
    }

    pub fn end(&self) -> Option<usize> {
        self.ends_by_start.values().next_back().copied()
    }
}

impl<I> From<I> for RangeUnion
where
    I: IntoIterator<Item = std::ops::Range<usize>>,
{
    fn from(value: I) -> Self {
        let mut result = Self::default();
        result.extend(value);
        result
    }
}

impl<'it> IntoIterator for &'it RangeUnion {
    type Item = std::ops::Range<usize>;
    type IntoIter = RangeUnionIterator<'it>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

pub struct RangeUnionIterator<'it> {
    position: std::collections::btree_map::Iter<'it, usize, usize>,
    current_interval: Option<(&'it usize, &'it usize)>,
    fill_gaps: usize,
}

impl Iterator for RangeUnionIterator<'_> {
    type Item = std::ops::Range<usize>;
    fn next(&mut self) -> Option<Self::Item> {
        match self.current_interval {
            None => None,
            Some((&first_start, &first_end)) => {
                let mut farthest_end: usize = first_end;
                loop {
                    self.current_interval = self.position.next();
                    match self.current_interval {
                        None => break Some(first_start..farthest_end),
                        Some((&start, &end)) => {
                            if start <= farthest_end + self.fill_gaps {
                                farthest_end = farthest_end.max(end);
                            } else {
                                break Some(first_start..farthest_end);
                            }
                        }
                    }
                }
            }
        }
    }
}