xdag 0.1.4

A simple Rust DAG(Directed Acyclic Graph) lib
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

use std::collections::HashMap;

/// iterator of the edges in `DAG`
pub struct EdgesIter<'a, NodeId, EdgeData> {
    pub(crate) from_iter: std::collections::hash_map::Iter<'a, NodeId, HashMap<NodeId, EdgeData>>,
    pub(crate) to_iter: Option<(
        NodeId,
        std::collections::hash_map::Iter<'a, NodeId, EdgeData>,
    )>,
}

impl<'a, NodeId, EdgeData> Iterator for EdgesIter<'a, NodeId, EdgeData>
where
    NodeId: Copy,
{
    type Item = (NodeId, NodeId, &'a EdgeData);

    fn next(&mut self) -> Option<Self::Item> {
        if let Some((from_id, iter)) = self.to_iter.as_mut().as_mut() {
            let from_id = from_id.clone();
            if let Some((to_id, data)) = iter.next() {
                return Some((from_id, to_id.clone(), data));
            }
        }
        // yield None or to_iter is none
        if let Some((from_id, map)) = self.from_iter.next() {
            let to_iter = map.iter();
            self.to_iter.replace((from_id.clone(), to_iter));
            self.next()
        } else {
            None
        }
    }
}

pub struct EdgesIterMut<'a, NodeId, EdgeData> {
    pub(crate) from_iter:
        std::collections::hash_map::IterMut<'a, NodeId, HashMap<NodeId, EdgeData>>,
    pub(crate) to_iter: Option<(
        NodeId,
        std::collections::hash_map::IterMut<'a, NodeId, EdgeData>,
    )>,
}

impl<'a, NodeId, EdgeData> Iterator for EdgesIterMut<'a, NodeId, EdgeData>
where
    NodeId: Copy,
{
    type Item = (NodeId, NodeId, &'a mut EdgeData);

    fn next(&mut self) -> Option<Self::Item> {
        if let Some((from_id, iter)) = self.to_iter.as_mut().as_mut() {
            let from_id = from_id.clone();
            if let Some((to_id, data)) = iter.next() {
                return Some((from_id, to_id.clone(), data));
            }
        }
        // yield None or to_iter is none
        if let Some((from_id, map)) = self.from_iter.next() {
            let to_iter = map.iter_mut();
            self.to_iter.replace((from_id.clone(), to_iter));
            self.next()
        } else {
            None
        }
    }
}