sinistra 0.1.0-202603071957

A generic graph framework with pluggable storage and topology and streaming graph algorithms.
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
109
110
111
112
113

use crate::graph::{
    EdgeHandle, EdgeTopology, EdgeTopologyMut, EndpointTopology, NeighborTopology, Topology,
    TopologyMut, VertexHandle, VertexSet, VertexSetMut,
};

pub struct Undirected<T>(T);

impl<T> Undirected<T> {
    pub const fn new(topology: T) -> Self {
        Self(topology)
    }
}

impl<T: VertexSet> VertexSet for Undirected<T> {
    type Vertices<'a>
        = T::Vertices<'a>
    where
        Self: 'a;

    fn vertices(&self) -> Self::Vertices<'_> {
        self.0.vertices()
    }
}

impl<T: NeighborTopology> NeighborTopology for Undirected<T> {
    type OutNeighbors<'a>
        = std::iter::Chain<T::OutNeighbors<'a>, T::InNeighbors<'a>>
    where
        Self: 'a;

    type InNeighbors<'a>
        = std::iter::Chain<T::OutNeighbors<'a>, T::InNeighbors<'a>>
    where
        Self: 'a;

    fn out_neighbors(&self, v: VertexHandle) -> Self::OutNeighbors<'_> {
        // TODO: Deduplicate the neighbors
        self.0.out_neighbors(v).chain(self.0.in_neighbors(v))
    }

    fn in_neighbors(&self, v: VertexHandle) -> Self::InNeighbors<'_> {
        // TODO: Deduplicate the neighbors
        self.0.out_neighbors(v).chain(self.0.in_neighbors(v))
    }
}

impl<T: EdgeTopology> EdgeTopology for Undirected<T> {
    type Edges<'a>
        = T::Edges<'a>
    where
        Self: 'a;

    type OutEdges<'a>
        = T::OutEdges<'a>
    where
        Self: 'a;

    type InEdges<'a>
        = T::InEdges<'a>
    where
        Self: 'a;

    fn edges(&self) -> Self::Edges<'_> {
        self.0.edges()
    }

    fn out_edges(&self, v: VertexHandle) -> Self::OutEdges<'_> {
        self.0.out_edges(v)
    }

    fn in_edges(&self, v: VertexHandle) -> Self::InEdges<'_> {
        self.0.in_edges(v)
    }
}

impl<T: EndpointTopology> EndpointTopology for Undirected<T> {
    fn edge_endpoints(&self, edge: EdgeHandle) -> Option<(VertexHandle, VertexHandle)> {
        self.0.edge_endpoints(edge)
    }
}

impl<T: Topology> Topology for Undirected<T> {
    type Adjacent<'a>
        = T::Adjacent<'a>
    where
        Self: 'a;

    fn adjacent(&self, v: VertexHandle) -> Self::Adjacent<'_> {
        self.0.adjacent(v)
    }
}

impl<T: VertexSetMut> VertexSetMut for Undirected<T> {
    fn add_vertex(&mut self, handle: VertexHandle) -> bool {
        self.0.add_vertex(handle)
    }

    fn remove_vertex(&mut self, handle: VertexHandle) -> bool {
        self.0.remove_vertex(handle)
    }
}

impl<T: EdgeTopologyMut> EdgeTopologyMut for Undirected<T> {
    fn add_edge(&mut self, handle: EdgeHandle, source: VertexHandle, target: VertexHandle) -> bool {
        self.0.add_edge(handle, source, target)
    }

    fn remove_edge(&mut self, handle: EdgeHandle) -> bool {
        self.0.remove_edge(handle)
    }
}

impl<T: TopologyMut> TopologyMut for Undirected<T> {}