Struct SingleMutableCsr 

pub struct SingleMutableCsr { /* private fields */ }

Implementations

impl SingleMutableCsr

pub fn iter(&self, ts: u64) -> SingleMutableCsrIterator<'_>

pub fn iter_all(&self) -> SingleMutableCsrIterator<'_>

Iterate over all physically present entries, including tombstoned ones.

impl SingleMutableCsr

pub fn delete_edge_at_position( &mut self, src: u32, position: EdgePosition, expected: EdgeId, ts: u64, ) -> Result<bool, StorageError>

Delete the single slot at position when it holds expected.

Only the row-local primary slot zero is valid; every other position is stale and refused without touching any slot.

pub fn revert_delete_at_position( &mut self, src: u32, position: EdgePosition, expected: EdgeId, ts: u64, ) -> bool

Revert the single-slot deletion at position when it holds expected.

pub fn delete_edge_by_dst_reporting_positioned( &mut self, src: u32, dst: VertexId, ts: u64, on_deleted: &mut dyn FnMut(EdgeId, Option<EdgePosition>), ) -> usize

Delete the single matching entry, reporting its row-local position.

pub fn reclaimable_count(&self, vid: u32, cutoff: u64) -> usize

pub fn vertex_census(&self, vid: u32) -> (usize, usize, usize)

pub fn vertex_reclaim_probe(&self, vid: u32, cutoff: u64) -> (usize, usize)

Single-slot reclaim probe: (dead, reclaimable) in one slot read.

pub fn compact_vertex_with_reporting( &mut self, vid: u32, cutoff: u64, on_edge_removed: &mut dyn FnMut(EdgeId, u64), ) -> usize

pub fn compact_with_ts_reporting( &mut self, cutoff: u64, on_edge_removed: &mut dyn FnMut(EdgeId, u64), ) -> usize

pub fn clear(&mut self)

impl SingleMutableCsr

pub fn dump(&self) -> Vec<u8>

Dump with integer column encoding for neighbor and edge-id columns.

Offsets are trivial for the single-edge layout (slot index equals row), so only neighbor, rank, edge-id and stamp columns go through the column path with a narrow plain fallback.

pub fn dump_into(&self, out: &mut Vec<u8>)

Borrow-based dump into out, byte-identical to dump. The payload carries a trailing CRC32 trailer verified on load.

pub fn used_memory_size(&self) -> usize

Reserved slot memory plus struct overhead.

Per-shape accounting by design: the single-slot layout owns no offset arrays, live sets or overflow maps, so its shard-level total is narrower than the multi-edge layout. Cross-shape comparison belongs at the table layer after the shared authority estimate is added, never at the shard level directly.

pub fn load(&mut self, data: &[u8]) -> Result<(), StorageError>

Load the single persisted layout. The trailing CRC32 is verified before any parsing.

impl SingleMutableCsr

pub fn get_edge(&self, src: u32, dst: VertexId, ts: u64) -> Option<Nbr>

pub fn locate_edge( &self, src: u32, edge_id: EdgeId, ) -> Option<(EdgePosition, Nbr)>

Locate the single slot holding edge_id, if any.

Returns the row-local primary position alongside a copy, including tombstoned slots so delete and revert callers can act on them.

pub fn nbr_at_offset(&self, src: u32, offset: i32) -> Option<Nbr>

pub fn get_edge_physical(&self, src: u32, dst: VertexId) -> Option<Nbr>

pub fn physical_edges_of(&self, src: u32) -> Vec<Nbr>

Test and offline use; production scans use fill_physical_into or the visitor paths instead of this allocating accessor.

pub fn fill_physical_into(&self, src: u32, out: &mut Vec<Nbr>)

Fill a caller buffer with the physically stored entry of one slot.

Same content as the allocating accessor above, without the per-vertex allocation. Lets batch scans share one buffer across vertices.

pub fn visit_physical<F>(&self, src: u32, f: F)

where F: FnMut(Nbr) -> bool,

pub fn visit_hot<F>(&self, src: u32, f: F)

where F: FnMut(HotNbr) -> bool,

Visit the single hot half of one vertex without allocating.

pub fn is_row_sorted(&self, _src: u32) -> bool

Single-slot rows hold at most one entry and are trivially ordered.

pub fn visit_threshold<F>( &self, src: u32, lower: Option<(u32, i64)>, upper: Option<(u32, i64)>, f: F, )

where F: FnMut(Nbr) -> bool,

Threshold visit over at most one live entry.

pub fn fill_threshold_into( &self, src: u32, lower: Option<(u32, i64)>, upper: Option<(u32, i64)>, out: &mut Vec<Nbr>, )

Fill a caller buffer with the same range content as visit_threshold.

pub fn has_physical_entries(&self, vid: u32) -> bool

pub fn primary_contains(&self, src: u32, edge_id: EdgeId) -> bool

pub fn edges_of(&self, src: u32, ts: u64) -> Vec<Nbr>

UNFILTERED single-predicate read for tests and offline tools only. Production reads must use iter_edges_of with the authority gate instead of collecting through this allocating accessor.

pub fn iter_edges_of(&self, src: u32, ts: u64) -> Option<Nbr>

Read the single slot of one vertex when it is alive at ts.

Allocation-free counterpart of edges_of: no vector is built for the one-entry row. Returns None for out-of-range rows and for slots that are empty or not alive at ts.

impl SingleMutableCsr

pub fn insert_edge( &mut self, src: u32, dst: VertexId, edge_id: EdgeId, _ts: u64, ) -> Result<(), StorageError>

pub fn delete_edge( &mut self, src: u32, edge_id: EdgeId, ts: u64, ) -> Result<bool, StorageError>

pub fn delete_edge_by_dst_reporting( &mut self, src: u32, dst: VertexId, ts: u64, on_deleted: &mut dyn FnMut(EdgeId), ) -> usize

Delete the single matching live entry for full-match endpoint semantics.

Returns the deleted count (0 or 1) so callers can reconcile. Reporting variant stamps the slot and hands the id to on_deleted in the same step, so no second lookup is needed.

pub fn delete_edge_by_dst(&mut self, src: u32, dst: VertexId, ts: u64) -> usize

Delete the single matching live entry for full-match endpoint semantics.

Returns the deleted count (0 or 1) so callers can reconcile.

pub fn revert_delete_by_offset( &mut self, src: u32, offset: i32, ts: u64, ) -> bool

pub fn delete_edge_by_offset( &mut self, src: u32, offset: i32, ts: u64, ) -> Result<bool, StorageError>

pub fn rollback_insert(&mut self, src: u32, edge_id: EdgeId) -> bool

pub fn revert_delete_by_edge_id( &mut self, src: u32, edge_id: EdgeId, ts: u64, ) -> bool

impl SingleMutableCsr

pub fn new() -> SingleMutableCsr

pub fn with_capacity(vertex_capacity: usize) -> SingleMutableCsr

pub fn vertex_capacity(&self) -> usize

pub fn edge_count(&self) -> u64

pub fn resize(&mut self, new_vertex_capacity: usize)

pub fn ensure_vertex_capacity(&mut self, min_capacity: usize)

Trait Implementations

impl Clone for SingleMutableCsr

fn clone(&self) -> SingleMutableCsr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CsrBase for SingleMutableCsr

fn vertex_capacity(&self) -> usize

Concurrency contract: row stores carry no internal locks. Concurrent reads are safe while no writer holds exclusive access, but any concurrent mutation requires caller-side mutual exclusion. The Send + Sync bounds express single-writer transfer across threads, not lock-free concurrent writes. Multi-core scaling comes from shard-level parallelism over NodeGroup shards above this trait; the CSR lock model itself stays single-writer with no row locks.

fn edge_count(&self) -> u64

fn dump(&self) -> Vec<u8>

fn dump_into(&self, out: &mut Vec<u8>)

Append the same bytes as dump into out without an intermediate owned buffer, so checkpoint writes borrow the live topology instead of cloning it for serialization.

fn load(&mut self, data: &[u8]) -> Result<(), StorageError>

impl Debug for SingleMutableCsr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for SingleMutableCsr

fn default() -> SingleMutableCsr

Returns the “default value” for a type.

impl MutableCsrTrait for SingleMutableCsr

fn insert_edge( &mut self, src: u32, dst: VertexId, edge_id: EdgeId, ts: u64, ) -> Result<(), StorageError>

Insert an edge.

fn delete_edge( &mut self, src: u32, edge_id: EdgeId, ts: u64, ) -> Result<bool, StorageError>

Delete an edge by edge_id.

fn delete_edge_by_dst(&mut self, src: u32, dst: VertexId, ts: u64) -> usize

Delete all edges matching (src, dst) with full-match semantics.

fn delete_edge_by_dst_reporting( &mut self, src: u32, dst: VertexId, ts: u64, on_deleted: &mut dyn FnMut(EdgeId), ) -> usize

Delete all edges matching (src, dst), reporting every stamped id.

fn delete_edge_by_dst_reporting_positioned( &mut self, src: u32, dst: VertexId, ts: u64, on_deleted: &mut dyn FnMut(EdgeId, Option<EdgePosition>), ) -> usize

Delete all edges matching (src, dst), reporting each stamped id with its row position.

fn locate_edge(&self, src: u32, edge_id: EdgeId) -> Option<(EdgePosition, Nbr)>

Locate one stored edge, returning its row position and copy.

fn delete_edge_at_position( &mut self, src: u32, position: EdgePosition, expected: EdgeId, ts: u64, ) -> Result<bool, StorageError>

Delete the edge at position when it still holds expected id.

fn revert_delete_at_position( &mut self, src: u32, position: EdgePosition, expected: EdgeId, ts: u64, ) -> bool

Revert the deletion at position when it still holds expected id.

fn delete_edge_by_offset( &mut self, src: u32, offset: i32, ts: u64, ) -> Result<bool, StorageError>

Delete an edge by its offset position in the primary block.

fn revert_delete_by_offset(&mut self, src: u32, offset: i32, ts: u64) -> bool

Revert a deleted edge by its offset position.

fn nbr_at_offset(&self, src: u32, offset: i32) -> Option<Nbr>

Read-only view of one primary slot for offset identity checks.

fn get_edge_physical(&self, src: u32, dst: VertexId) -> Option<Nbr>

Locate the first live edge by endpoint without consulting snapshots.

fn physical_edges_of(&self, src: u32) -> Vec<Nbr>

Every physically stored entry of one vertex without timestamp filtering.

fn fill_physical_into(&self, src: u32, out: &mut Vec<Nbr>)

Fill a caller buffer with every physically stored entry of one vertex.

fn has_physical_entries(&self, vid: u32) -> bool

Whether one vertex holds any physically stored entry.

fn primary_contains(&self, src_vid: u32, edge_id: EdgeId) -> bool

Whether the primary row of one vertex holds edge_id.

fn rollback_insert(&mut self, src_vid: u32, edge_id: EdgeId) -> bool

Erase one just-inserted edge for insert rollback (no tombstone trace).

fn revert_delete_by_edge_id( &mut self, src_vid: u32, edge_id: EdgeId, ts: u64, ) -> bool

Revert a deletion by edge id if it happened at or before ts.

fn get_edge(&self, src: u32, dst: VertexId, ts: u64) -> Option<Nbr>

Get a specific edge by source and destination. Test-only row-stamp filter; production reads go through the version authority.

fn edges_of(&self, src: u32, ts: u64) -> Vec<Nbr>

Get all valid edges of a vertex at the given timestamp. Test-only row-stamp filter; production reads go through the version authority. Test and offline use; production traversals use the visitor or caller-buffer fill paths instead of this allocating accessor.

fn reclaimable_count(&self, vid: u32, cutoff: u64) -> usize

Count entries of one vertex that are reclaimable at cutoff.

fn vertex_census(&self, vid: u32) -> (usize, usize, usize)

Physical entry census of one vertex: (live, dead, capacity).

fn vertex_reclaim_probe(&self, vid: u32, cutoff: u64) -> (usize, usize)

Single-walk reclaim probe of one vertex: (dead, reclaimable).

fn compact_vertex_with_reporting( &mut self, vid: u32, cutoff: u64, on_edge_removed: &mut dyn FnMut(EdgeId, u64), ) -> usize

Reclaim one vertex in place, dropping entries eligible for collection at cutoff and tightening live entries without touching other rows.

fn used_memory_size(&self) -> usize

Return the approximate memory usage in bytes.

fn vertex_needs_compact(&self, vid: u32, cutoff: u64) -> bool

Whether one vertex holds anything reclaimable at cutoff.

fn row_gap(&self, _vid: u32) -> usize

Reserved primary slots minus live primary entries of one row.

fn row_density(&self, _vid: u32) -> f32

Live primary entries per unit of reserved primary capacity.

fn rebalance_row(&mut self, _vid: u32) -> bool

Rebalance one row in place, pulling overflow entries into primary gaps and repacking leftover overflow. Returns true when the row no longer holds overflow. Strategies without rows report true.