Struct EdgeCluster 

pub struct EdgeCluster { /* private fields */ }

Serialized cluster holding all edges for a node in a given direction.

Implementations

impl EdgeCluster

pub fn create_from_edges( edges: &[EdgeRecord], node_id: i64, direction: Direction, string_table: &mut StringTable, ) -> NativeResult<Self>

Build a cluster from a slice of canonical EdgeRecords.

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

Serialize cluster header + payload. CRITICAL FIX: Ensure the final buffer size matches header expectations exactly.

pub fn verify_serialized_layout(bytes: &[u8]) -> NativeResult<()>

Validate serialized bytes before writing to disk.

pub fn deserialize(bytes: &[u8]) -> NativeResult<Self>

Rebuild a cluster from raw bytes. Rebuild a cluster from raw bytes.

pub fn edge_count(&self) -> u32

Number of edges stored in this cluster.

pub fn size_bytes(&self) -> usize

Total bytes including cluster header.

pub fn iter_neighbors(&self) -> impl Iterator<Item = i64> + '_

Iterate over neighbor node IDs stored in this cluster.

pub fn iter_decompress(&self) -> impl Iterator<Item = CompactEdgeRecord> + '_

Iterate over edges using lazy decompression from serialized bytes.

This method provides a zero-allocation iterator that decompresses edges on-the-fly, improving cache locality for large clusters.

Returns

An iterator that yields CompactEdgeRecord items

pub fn decompress_from_bytes( bytes: &[u8], ) -> NativeResult<DecompressEdgeIterator<'_>>

Create a decompression iterator from raw serialized bytes.

This is useful for edge clusters that haven’t been fully deserialized yet, allowing for lazy loading and improved memory efficiency.

Arguments

• bytes - Raw serialized cluster bytes

Returns

A DecompressEdgeIterator that yields edges on-demand

pub fn is_efficient(&self) -> bool

Return whether the cluster meets compactness heuristics.

pub fn validate(&self) -> NativeResult<()>

Validate record integrity.

pub fn set_offset(&mut self, offset: FileOffset)

Set file offset once the cluster has been written to disk.

pub fn offset(&self) -> FileOffset

Retrieve the cluster’s file offset.

pub fn payload_size(&self) -> usize

Get the serialized payload size (excluding header).

pub fn edges(&self) -> &[CompactEdgeRecord]

Borrow the compact edges (used when flushing clusters).

pub fn create_from_compact_edges( compact_edges: Vec<CompactEdgeRecord>, _node_id: i64, _direction: Direction, ) -> NativeResult<Self>

Create cluster directly from compact edges without EdgeRecord reconstruction. This is the new pipeline method that treats compact edges as authoritative. CRITICAL FIX: Ensure serialized_size exactly matches the actual payload bytes.

pub fn get_neighbors_with_cache( &self, cache: &ThreadSafeCache, node_id: i64, direction: Direction, ) -> Vec<i64>

Get neighbors with cache support. This is a cache-aware wrapper around iter_neighbors that records access patterns.

For high-degree nodes (degree > 1000), we recommend caching only neighbor IDs rather than the full cluster to reduce memory pressure.

pub fn prefetch_neighbors<F>( &self, cache: &ThreadSafeCache, neighbor_ids: &[i64], get_cluster_fn: F, direction: Direction, )

where F: Fn(i64, Direction) -> Option<EdgeCluster>,

Prefetch neighboring clusters into cache for traversal optimization. This loads clusters for the next hop in a BFS/DFS traversal.

Arguments:

• cache: The thread-safe cache to populate
• neighbor_ids: IDs of neighbors to prefetch
• get_cluster_fn: Function to load cluster if not in cache
• direction: Direction of edges to prefetch

pub fn is_high_degree_node(&self) -> bool

Check if this is a high-degree node that should get special cache treatment.

Trait Implementations

impl Clone for EdgeCluster

fn clone(&self) -> EdgeCluster

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EdgeCluster

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

Formats the value using the given formatter.