graph-api-simplegraph 0.2.2

A simple, efficient graph implementation for the graph-api ecosystem with support for indexing
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
134
135
136

use crate::SimpleGraph;
use graph_api_lib::{Element, ElementId};

/// Simple vertex identifier using direct numeric values
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Hash)]
pub struct VertexId {
    label: u16,
    vertex_id: u32,
}

impl VertexId {
    /// Creates a new VertexId
    ///
    /// # Arguments
    /// * `label_id` - The label identifier
    /// * `vertex_id` - The unique vertex identifier
    pub fn new(label: u16, vertex_id: u32) -> Self {
        Self { label, vertex_id }
    }

    pub fn label(&self) -> u16 {
        self.label
    }

    pub fn vertex(&self) -> u32 {
        self.vertex_id
    }
}

/// Simple edge identifier using direct numeric values
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Hash)]
pub struct EdgeId {
    label: u16,
    edge_id: u32,
    head: VertexId,
    tail: VertexId,
}

impl EdgeId {
    pub fn new(label: u16, edge_id: u32, tail: VertexId, head: VertexId) -> Self {
        Self {
            label,
            edge_id,
            head,
            tail,
        }
    }

    pub fn label(&self) -> u16 {
        self.label
    }

    pub fn edge(&self) -> u32 {
        self.edge_id
    }

    pub(crate) fn head(&self) -> VertexId {
        self.head
    }

    pub(crate) fn tail(&self) -> VertexId {
        self.tail
    }
}

impl<Vertex, Edge> From<VertexId> for ElementId<SimpleGraph<Vertex, Edge>>
where
    Vertex: Element,
    Edge: Element,
{
    fn from(val: VertexId) -> Self {
        ElementId::Vertex(val)
    }
}

impl<Vertex, Edge> From<EdgeId> for ElementId<SimpleGraph<Vertex, Edge>>
where
    Vertex: Element,
    Edge: Element,
{
    fn from(val: EdgeId) -> Self {
        ElementId::Edge(val)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_vertex_id() {
        let label_id = 42u16;
        let vertex_id = 12345u32;
        let vid = VertexId::new(label_id, vertex_id);

        assert_eq!(vid.label(), label_id);
        assert_eq!(vid.vertex(), { vertex_id });
    }

    #[test]
    fn test_edge_id() {
        let label_id = 24u16;
        let edge_id = 67890u32;
        let head = VertexId::new(1, 100);
        let tail = VertexId::new(2, 200);

        let eid = EdgeId::new(label_id, edge_id, tail, head);

        assert_eq!(eid.label(), label_id);
        assert_eq!(eid.edge(), edge_id);
        assert_eq!(eid.head().vertex(), head.vertex());
        assert_eq!(eid.tail().vertex(), tail.vertex());
    }

    #[test]
    fn test_id_conversion() {
        let vid = VertexId::new(1, 100);
        let eid = EdgeId::new(2, 200, vid, VertexId::new(3, 300));

        // Using SimpleGraph type for ElementId parameter
        type TestGraph = SimpleGraph<(), ()>;

        let id1: ElementId<TestGraph> = vid.into();
        let id2: ElementId<TestGraph> = eid.into();

        match id1 {
            ElementId::Vertex(v) => assert_eq!(v, vid),
            _ => panic!("Expected Vertex ID"),
        }

        match id2 {
            ElementId::Edge(e) => assert_eq!(e, eid),
            _ => panic!("Expected Edge ID"),
        }
    }
}