safegraph 0.1.0

A type-safe, scope-aware graph library that leverages Rust's type system to prevent common graph-related bugs at compile time
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use safegraph::graph::capability::*;
use safegraph::graph::prelude::*;
use safegraph::{BTreeGraph, VecGraph};

fn diamond_btree() -> BTreeGraph<u32, u32> {
    let mut g = BTreeGraph::<u32, u32>::default();
    g.insert_node(0).unwrap();
    g.insert_node(1).unwrap();
    g.insert_node(2).unwrap();
    g.insert_node(3).unwrap();
    g.insert_edge(10, [0, 1]).unwrap();
    g.insert_edge(11, [0, 2]).unwrap();
    g.insert_edge(12, [1, 3]).unwrap();
    g.insert_edge(13, [2, 3]).unwrap();
    g
}

fn diamond_vec() -> (VecGraph<u32, u32>, [u32; 4], [u32; 4]) {
    let mut g = VecGraph::<u32, u32>::default();
    let n0 = unsafe { InsertNode::insert_node_unchecked(&mut g, 0).unwrap() };
    let n1 = unsafe { InsertNode::insert_node_unchecked(&mut g, 1).unwrap() };
    let n2 = unsafe { InsertNode::insert_node_unchecked(&mut g, 2).unwrap() };
    let n3 = unsafe { InsertNode::insert_node_unchecked(&mut g, 3).unwrap() };
    let e0 = unsafe { InsertEdge::insert_edge_unchecked(&mut g, 10, [n0, n1]).unwrap() };
    let e1 = unsafe { InsertEdge::insert_edge_unchecked(&mut g, 11, [n0, n2]).unwrap() };
    let e2 = unsafe { InsertEdge::insert_edge_unchecked(&mut g, 12, [n1, n3]).unwrap() };
    let e3 = unsafe { InsertEdge::insert_edge_unchecked(&mut g, 13, [n2, n3]).unwrap() };
    (g, [n0, n1, n2, n3], [e0, e1, e2, e3])
}

#[test]
fn scoped_node_ix_inner_btree() {
    let g = diamond_btree();
    g.scope(|ctx| {
        let nodes: Vec<_> = ctx.node_indices().collect();
        // inner() returns the underlying BTreeGraph NodeIx (&u32)
        let inner = nodes[0].inner();
        assert_eq!(inner, 0);
    });
}

#[test]
fn scoped_edge_ix_inner_btree() {
    let g = diamond_btree();
    g.scope(|ctx| {
        let edges: Vec<_> = ctx.edge_indices().collect();
        let inner = edges[0].inner();
        assert_eq!(inner, 10);
    });
}

#[test]
fn scoped_node_ix_display_vec() {
    let (g, _, _) = diamond_vec();
    g.scope(|ctx| {
        let nodes: Vec<_> = ctx.node_indices().collect();
        let s = format!("{}", nodes[0]);
        assert_eq!(s, "0");
    });
}

#[test]
fn scoped_edge_ix_display_vec() {
    let (g, _, _) = diamond_vec();
    g.scope(|ctx| {
        let edges: Vec<_> = ctx.edge_indices().collect();
        let s = format!("{}", edges[0]);
        assert_eq!(s, "0");
    });
}

#[test]
fn scoped_node_ix_equality_btree() {
    let g = diamond_btree();
    g.scope(|ctx| {
        let nodes: Vec<_> = ctx.node_indices().collect();
        let n0_again = ctx.node_index(0).unwrap();
        assert_eq!(nodes[0], n0_again);
    });
}

#[test]
fn scoped_node_ix_ordering_btree() {
    let g = diamond_btree();
    g.scope(|ctx| {
        let nodes: Vec<_> = ctx.node_indices().collect();
        // BTreeGraph produces sorted node indices, scoped indices preserve order
        assert!(nodes[0] < nodes[1]);
        assert!(nodes[1] < nodes[2]);
    });
}

#[test]
fn scoped_edge_ix_inner_vec() {
    let (g, _, _) = diamond_vec();
    g.scope(|ctx| {
        let edges: Vec<_> = ctx.edge_indices().collect();
        let inner = edges[0].inner();
        // inner() returns the underlying VecGraph EdgeIx (a bare `u32`)
        let s = format!("{inner}");
        assert_eq!(s, "0");
    });
}

#[test]
fn scope_directed_edges_to_btree() {
    let g = diamond_btree();
    g.scope(|ctx| {
        let n3 = ctx.node_index(3).unwrap();
        let incoming: Vec<_> = ctx.edges_to(n3).collect();
        assert_eq!(incoming.len(), 2);
    });
}

#[test]
fn scope_edge_indices_of_btree() {
    let g = diamond_btree();
    g.scope(|ctx| {
        let n1 = ctx.node_index(1).unwrap();
        let all: Vec<_> = ctx.edge_indices_of(n1).collect();
        assert_eq!(all.len(), 2);
    });
}

#[test]
fn scope_incident_indices_btree() {
    let g = diamond_btree();
    g.scope(|ctx| {
        let n1 = ctx.node_index(1).unwrap();
        let inc: Vec<_> = ctx.neighbor_indices_of(n1).collect();
        assert_eq!(inc.len(), 2);
    });
}