Struct PrefixIndex 

pub struct PrefixIndex { /* private fields */ }

Concurrent prefix → nodes index. The internal map is DashMap keyed by the 32-byte digest. Per-prefix node lists are guarded by a RwLock to avoid lock contention on hot keys.

Implementations

impl PrefixIndex

pub fn new(ttl: Duration) -> Self

pub fn insert(&self, digest: [u8; 32], node_id: &str)

Record that node_id currently holds digest.

pub fn forget_node(&self, node_id: &str)

Drop a node from the index entirely (invoked on graceful drain).

pub fn lookup(&self, digest: &[u8; 32]) -> Vec<String>

Look up the live nodes that currently hold digest.

pub fn overlap(&self, digests: &[[u8; 32]]) -> HashMap<String, usize>

Compute, for every node, how many of digests it holds. Returns a hash map of node_id -> count. The router uses this to score nodes by content overlap.

This counts every matching digest regardless of position. Use Self::longest_prefix_overlap when the digests are sequence-chained (hash_seq_chunks) and you want the actual length of the cached prefix the node can serve without a prefill.

pub fn longest_prefix_overlap( &self, digests: &[[u8; 32]], ) -> HashMap<String, usize>

For each node, report the length of the longest contiguous prefix of digests (starting at index 0) that the node holds.

digests MUST be sequence-chained — i.e. produced by crate::hash::hash_seq_chunks — otherwise the result is meaningless. With sequence-chained digests, “node X holds chunks 0..K in the right order” reduces to “node X has digest_i for every i in 0..K”, because the chained hash already encodes positional dependency.

Returns node_id -> prefix_length_in_chunks for every node that holds at least chunk 0. Nodes with no prefix overlap are absent from the map.

pub fn len(&self) -> usize

Total tracked digests.

pub fn is_empty(&self) -> bool

Trait Implementations

impl Default for PrefixIndex

fn default() -> PrefixIndex

Returns the “default value” for a type.