gryf 0.2.1

Graph data structure library with focus on convenience, versatility, correctness and performance.
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

//! Adapter that removes directionality of edges of a directed graph.

use crate::core::{
    GraphBase, Neighbors,
    marker::{Direction, Undirected},
};

use gryf_derive::{EdgeSet, Guarantee, VertexSet};

/// Adapter that removes directionality of edges of a directed graph.
#[derive(Debug, VertexSet, EdgeSet, Guarantee)]
#[gryf_crate]
pub struct Undirect<G> {
    #[graph]
    graph: G,
}

impl<G> Undirect<G> {
    /// Creates a new graph which removes directionality of edges of the given
    /// graph.
    pub fn new(graph: G) -> Self {
        Self { graph }
    }

    /// Consumes the adapter and returns the wrapped graph.
    pub fn into_inner(self) -> G {
        self.graph
    }
}

impl<G> GraphBase for Undirect<G>
where
    G: GraphBase,
{
    type VertexId = G::VertexId;
    type EdgeId = G::EdgeId;
    type EdgeType = Undirected;
}

impl<G> Neighbors for Undirect<G>
where
    G: Neighbors,
{
    type NeighborRef<'a>
        = G::NeighborRef<'a>
    where
        Self: 'a;

    type NeighborsIter<'a>
        = G::NeighborsIter<'a>
    where
        Self: 'a;

    fn neighbors_undirected(&self, from: &Self::VertexId) -> Self::NeighborsIter<'_> {
        self.graph.neighbors_undirected(from)
    }

    fn neighbors_directed(
        &self,
        from: &Self::VertexId,
        _dir: Direction,
    ) -> Self::NeighborsIter<'_> {
        self.neighbors_undirected(from)
    }

    fn degree_undirected(&self, id: &Self::VertexId) -> usize {
        self.graph.degree_undirected(id)
    }

    fn degree_directed(&self, id: &Self::VertexId, _dir: Direction) -> usize {
        self.graph.degree_undirected(id)
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        core::{GraphAdd, marker::Directed},
        storage::AdjList,
    };

    use super::*;

    #[test]
    fn neighbors() {
        let mut graph = AdjList::<_, _, Directed, _>::default();

        let v0 = graph.add_vertex(());
        let v1 = graph.add_vertex(());
        let v2 = graph.add_vertex(());

        graph.add_edge(&v0, &v1, ());
        graph.add_edge(&v2, &v0, ());

        let graph = Undirect::new(graph);

        assert_eq!(
            graph.neighbors_directed(&v0, Direction::Outgoing).count(),
            2
        );
        assert_eq!(
            graph.neighbors_directed(&v0, Direction::Incoming).count(),
            2
        );
        assert_eq!(graph.degree_directed(&v0, Direction::Outgoing), 2);
        assert_eq!(graph.degree_directed(&v0, Direction::Incoming), 2);
    }
}