Skip to main content

linkrs_storage/edge/mutable_csr/
trait_impl.rs

1use super::super::{CsrBase, EdgeId, EdgePosition, MutableCsrTrait, Nbr, Timestamp, VertexId};
2use super::MutableCsr;
3use linkrs_core::StorageResult;
4
5impl CsrBase for MutableCsr {
6    fn vertex_capacity(&self) -> usize {
7        MutableCsr::vertex_capacity(self)
8    }
9
10    fn edge_count(&self) -> u64 {
11        self.edge_count
12    }
13
14    fn dump(&self) -> Vec<u8> {
15        MutableCsr::dump(self)
16    }
17
18    fn dump_into(&self, out: &mut Vec<u8>) {
19        MutableCsr::dump_into(self, out)
20    }
21
22    fn load(&mut self, data: &[u8]) -> StorageResult<()> {
23        MutableCsr::load(self, data)
24    }
25}
26
27impl MutableCsrTrait for MutableCsr {
28    fn insert_edge(
29        &mut self,
30        src_vid: u32,
31        dst: VertexId,
32        edge_id: EdgeId,
33        ts: Timestamp,
34    ) -> StorageResult<()> {
35        MutableCsr::insert_edge(self, src_vid, dst, edge_id, ts)
36    }
37
38    fn delete_edge(&mut self, src_vid: u32, edge_id: EdgeId, ts: Timestamp) -> StorageResult<bool> {
39        MutableCsr::delete_edge(self, src_vid, edge_id, ts)
40    }
41
42    fn delete_edge_by_dst(&mut self, src_vid: u32, dst: VertexId, ts: Timestamp) -> usize {
43        MutableCsr::delete_edge_by_dst(self, src_vid, dst, ts)
44    }
45
46    fn delete_edge_by_dst_reporting(
47        &mut self,
48        src_vid: u32,
49        dst: VertexId,
50        ts: Timestamp,
51        on_deleted: &mut dyn FnMut(EdgeId),
52    ) -> usize {
53        MutableCsr::delete_edge_by_dst_reporting(self, src_vid, dst, ts, on_deleted)
54    }
55
56    fn delete_edge_by_dst_reporting_positioned(
57        &mut self,
58        src_vid: u32,
59        dst: VertexId,
60        ts: Timestamp,
61        on_deleted: &mut dyn FnMut(EdgeId, Option<EdgePosition>),
62    ) -> usize {
63        MutableCsr::delete_edge_by_dst_reporting_positioned(
64            self,
65            src_vid,
66            dst,
67            ts,
68            &mut |edge_id, position| on_deleted(edge_id, Some(position)),
69        )
70    }
71
72    fn locate_edge(&self, src_vid: u32, edge_id: EdgeId) -> Option<(EdgePosition, Nbr)> {
73        MutableCsr::locate_edge(self, src_vid, edge_id)
74    }
75
76    fn delete_edge_at_position(
77        &mut self,
78        src_vid: u32,
79        position: EdgePosition,
80        expected: EdgeId,
81        ts: Timestamp,
82    ) -> StorageResult<bool> {
83        MutableCsr::delete_edge_at_position(self, src_vid, position, expected, ts)
84    }
85
86    fn revert_delete_at_position(
87        &mut self,
88        src_vid: u32,
89        position: EdgePosition,
90        expected: EdgeId,
91        ts: Timestamp,
92    ) -> bool {
93        MutableCsr::revert_delete_at_position(self, src_vid, position, expected, ts)
94    }
95
96    fn delete_edge_by_offset(
97        &mut self,
98        src_vid: u32,
99        offset: i32,
100        ts: Timestamp,
101    ) -> StorageResult<bool> {
102        MutableCsr::delete_edge_by_offset(self, src_vid, offset, ts)
103    }
104
105    fn revert_delete_by_offset(&mut self, src_vid: u32, offset: i32, ts: Timestamp) -> bool {
106        MutableCsr::revert_delete_by_offset(self, src_vid, offset, ts)
107    }
108
109    fn nbr_at_offset(&self, src_vid: u32, offset: i32) -> Option<Nbr> {
110        MutableCsr::nbr_at_offset(self, src_vid, offset)
111    }
112
113    fn get_edge_physical(&self, src_vid: u32, dst: VertexId) -> Option<Nbr> {
114        MutableCsr::get_edge_physical(self, src_vid, dst)
115    }
116
117    fn physical_edges_of(&self, src_vid: u32) -> Vec<Nbr> {
118        MutableCsr::physical_edges_of(self, src_vid)
119    }
120
121    fn fill_physical_into(&self, src_vid: u32, out: &mut Vec<Nbr>) {
122        MutableCsr::fill_physical_into(self, src_vid, out)
123    }
124
125    fn has_physical_entries(&self, vid: u32) -> bool {
126        MutableCsr::has_physical_entries(self, vid)
127    }
128
129    fn primary_contains(&self, src_vid: u32, edge_id: EdgeId) -> bool {
130        MutableCsr::primary_contains(self, src_vid, edge_id)
131    }
132
133    fn rollback_insert(&mut self, src_vid: u32, edge_id: EdgeId) -> bool {
134        MutableCsr::rollback_insert(self, src_vid, edge_id)
135    }
136
137    fn revert_delete_by_edge_id(&mut self, src_vid: u32, edge_id: EdgeId, ts: Timestamp) -> bool {
138        MutableCsr::revert_delete_by_edge_id(self, src_vid, edge_id, ts)
139    }
140
141    fn get_edge(&self, src_vid: u32, dst: VertexId, ts: Timestamp) -> Option<Nbr> {
142        MutableCsr::get_edge(self, src_vid, dst, ts)
143    }
144
145    fn edges_of(&self, src_vid: u32, ts: Timestamp) -> Vec<Nbr> {
146        MutableCsr::edges_of(self, src_vid, ts)
147    }
148
149    fn compact_vertex_with_reporting(
150        &mut self,
151        vid: u32,
152        cutoff: Timestamp,
153        on_edge_removed: &mut dyn FnMut(EdgeId, Timestamp),
154    ) -> usize {
155        MutableCsr::compact_vertex_with_reporting(self, vid, cutoff, on_edge_removed)
156    }
157
158    fn reclaimable_count(&self, vid: u32, cutoff: Timestamp) -> usize {
159        MutableCsr::reclaimable_count(self, vid, cutoff)
160    }
161
162    fn vertex_needs_compact(&self, vid: u32, cutoff: Timestamp) -> bool {
163        MutableCsr::vertex_needs_compact(self, vid, cutoff)
164    }
165
166    fn vertex_census(&self, vid: u32) -> (usize, usize, usize) {
167        MutableCsr::vertex_census(self, vid)
168    }
169
170    fn vertex_reclaim_probe(&self, vid: u32, cutoff: Timestamp) -> (usize, usize) {
171        MutableCsr::vertex_reclaim_probe(self, vid, cutoff)
172    }
173
174    fn row_gap(&self, vid: u32) -> usize {
175        MutableCsr::row_gap(self, vid)
176    }
177
178    fn row_density(&self, vid: u32) -> f32 {
179        MutableCsr::row_density(self, vid)
180    }
181
182    fn rebalance_row(&mut self, vid: u32) -> bool {
183        MutableCsr::rebalance_row(self, vid)
184    }
185
186    fn used_memory_size(&self) -> usize {
187        MutableCsr::used_memory_size(self)
188    }
189}