Struct ConcurrentEdgeStore 

pub struct ConcurrentEdgeStore { /* private fields */ }

A thread-safe edge store using sharded locking.

Distributes edges across multiple shards based on source node ID to reduce lock contention in multi-threaded scenarios.

Cross-Shard Edge Storage Pattern

Edges that span different shards (source and target in different shards) are stored in BOTH shards:

• Source shard: Full edge with outgoing + label indices (add_edge)
• Target shard: Edge copy with incoming index only (add_edge_incoming_only)

Lock Ordering

When acquiring multiple shard locks, always acquire in ascending shard index order to prevent deadlocks.

Implementations

impl ConcurrentEdgeStore

pub fn get_outgoing(&self, node_id: u64) -> Vec<GraphEdge>

Gets all outgoing edges from a node (thread-safe).

pub fn get_incoming(&self, node_id: u64) -> Vec<GraphEdge>

Gets all incoming edges to a node (thread-safe).

pub fn get_neighbors(&self, node_id: u64) -> Vec<u64>

Gets neighbors (target nodes) of a given node.

pub fn get_outgoing_by_label(&self, node_id: u64, label: &str) -> Vec<GraphEdge>

Gets outgoing edges filtered by label (thread-safe).

Performance Note

This method delegates to the underlying EdgeStore::get_outgoing_by_label which uses the composite index (source_id, label) -> edge_ids for O(1) lookup when available (EPIC-019 US-003). Falls back to filtering if index not populated.

pub fn get_incoming_by_label(&self, node_id: u64, label: &str) -> Vec<GraphEdge>

Gets incoming edges filtered by label (thread-safe).

pub fn get_edges_by_label(&self, label: &str) -> Vec<GraphEdge>

Gets all edges with a specific label across all shards.

Performance Warning

This method iterates through ALL shards and aggregates results. For large graphs with many shards, this can be expensive. Consider using get_outgoing_by_label(node_id, label) if you know the source node, which is O(k) instead of O(shards × edges_per_label).

pub fn contains_edge(&self, edge_id: u64) -> bool

Checks if an edge with the given ID exists.

pub fn get_edge(&self, edge_id: u64) -> Option<GraphEdge>

Gets an edge by ID using optimized source shard lookup.

Returns None if the edge doesn’t exist.

pub fn traverse_bfs(&self, start: u64, max_depth: u32) -> Vec<u64>

Traverses the graph using BFS from a starting node.

Returns all nodes reachable within max_depth hops.

Uses Read-Copy-Drop pattern to avoid holding locks during traversal.

pub fn edge_count(&self) -> usize

Returns the total edge count across all shards.

Uses outgoing edge count to avoid double-counting edges that span shards.

impl ConcurrentEdgeStore

pub fn new() -> Self

Creates a new concurrent edge store with the default number of shards.

pub fn with_shards(num_shards: usize) -> Self

Creates a new concurrent edge store with a specific number of shards.

Panics

Panics if num_shards is 0 (would cause division-by-zero in shard_index).

pub fn with_estimated_edges(estimated_edges: usize) -> Self

Creates a concurrent edge store with optimal shard count for estimated edge count.

FLAG-6: Uses integer bit manipulation for ceiling log2.

pub fn add_edge(&self, edge: GraphEdge) -> Result<()>

Adds an edge to the store (thread-safe).

Edges are stored in BOTH source and target shards:

• Source shard: for outgoing index lookups
• Target shard: for incoming index lookups

When source and target are in different shards, locks are acquired in ascending shard index order to prevent deadlocks.

Errors

Returns Error::EdgeExists if an edge with the same ID already exists.

pub fn remove_edge(&self, edge_id: u64)

Removes an edge by ID using optimized 2-shard lookup.

Concurrency Safety

Lock ordering: edge_ids FIRST, then shards in ascending order.

pub fn remove_node_edges(&self, node_id: u64)

Removes all edges connected to a node (cascade delete, thread-safe).

Concurrency Safety

Lock ordering: edge_ids FIRST, then shards in ascending order.

Trait Implementations

impl Default for ConcurrentEdgeStore

fn default() -> Self

Returns the “default value” for a type.