weavatrix-graph 0.6.2

Deterministic, evidence-carrying graph core for Weavatrix repository intelligence
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

use super::core::NeighborStorage;
use crate::NodeIndex;

/// Exact-size lazy iterator over direct neighbor node indexes.
#[derive(Debug, Clone)]
pub struct NeighborIter<'cache> {
    storage: &'cache NeighborStorage,
    front: usize,
    back: usize,
}

impl<'cache> NeighborIter<'cache> {
    pub(super) const fn new(storage: &'cache NeighborStorage, front: usize, back: usize) -> Self {
        Self {
            storage,
            front,
            back,
        }
    }

    pub(super) const fn empty(storage: &'cache NeighborStorage) -> Self {
        Self::new(storage, 0, 0)
    }
}

impl Iterator for NeighborIter<'_> {
    type Item = NodeIndex;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        if self.front == self.back {
            return None;
        }
        let value = self.storage.get(self.front);
        self.front += 1;
        Some(NodeIndex::new(value))
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let remaining = self.back - self.front;
        (remaining, Some(remaining))
    }
}

impl DoubleEndedIterator for NeighborIter<'_> {
    #[inline]
    fn next_back(&mut self) -> Option<Self::Item> {
        if self.front == self.back {
            return None;
        }
        self.back -= 1;
        Some(NodeIndex::new(self.storage.get(self.back)))
    }
}

impl ExactSizeIterator for NeighborIter<'_> {}