Struct DirPathsPool 

pub(super) struct DirPathsPool {
    paths: Vec<Option<Box<[u8]>>>,
    covers_entries: usize,
    topo_generation: u64,
}

Memoized full paths for every directory, for one name pool. Only built when the query contains path terms — and split per pool so a query only pays for the pool(s) it reads (nearly all path queries are folded). Entry paths are memo[parent] + name.

Across generations a memo extends incrementally as long as no existing directory was renamed or moved (dir_topology_generation): appends never change old dir paths, so new dirs just memoize on top. A topology change rebuilds from scratch — dir renames are rare and the alternative (subtree invalidation) is not worth its complexity.

Fields

paths: Vec<Option<Box<[u8]>>>

covers_entries: usize

Entries [0, covers_entries) are memoized.

topo_generation: u64

The dir-topology generation this memo is valid for.

Implementations

impl DirPathsPool

fn name_of(idx: &VolumeIndex, id: EntryId, folded: bool) -> &[u8]

fn extend(idx: &VolumeIndex, pool: Self, folded: bool) -> Self

Extend pool to the current generation: memoize only the appended dirs. Their parents were live entries when pushed (lower id or root), so one increasing-id pass resolves every prefix. Falls back to a full build when a dir was renamed/moved (paths of arbitrary descendants changed) — the normal policy switch, not a degradation.

fn build(idx: &VolumeIndex, folded: bool) -> Self

Level-order parallel build: a directory’s path depends only on its parent’s (one level up), so each depth level fans out across cores.

fn parent_prefix(&self, parent: EntryId) -> &[u8]

fn bytes(&self) -> u64

Trait Implementations

impl From<DirPathsLower> for DirPathsPool

fn from(m: DirPathsLower) -> Self

Converts to this type from the input type.

impl From<DirPathsOrig> for DirPathsPool

fn from(m: DirPathsOrig) -> Self

Converts to this type from the input type.