Struct ProcessTree 

pub struct ProcessTree { /* private fields */ }

A process tree flattened into display order.

Implementations

impl ProcessTree

pub fn from_snapshot(snapshot: &SystemSnapshot, sort: ProcessSort) -> Self

Builds the tree of every process in snapshot.

pub fn from_snapshot_filtered( snapshot: &SystemSnapshot, sort: ProcessSort, filter: &ProcessFilter, ) -> Self

Builds the tree of the processes in snapshot that pass filter.

pub fn build<P: Borrow<ProcessSnapshot>>( processes: &[P], sort: ProcessSort, ) -> Self

Builds the tree of every process in processes.

pub fn build_filtered<P: Borrow<ProcessSnapshot>>( processes: &[P], sort: ProcessSort, filter: &ProcessFilter, ) -> Self

Builds the tree of the processes that pass filter.

A hidden process does not orphan its children: they re-attach to the nearest surviving ancestor, so hiding kernel threads or filtering by name reshapes the tree without scattering unrelated rows to the root. Rows that do not pass the filter simply do not appear.

pub fn rows(&self) -> &[TreeRow]

Every row, in display order.

pub fn len(&self) -> usize

How many rows the tree has.

pub fn is_empty(&self) -> bool

Whether the tree has no rows.

pub fn row(&self, index: usize) -> Option<&TreeRow>

The row at index, if there is one.

pub fn row_of(&self, identity: ProcessIdentity) -> Option<usize>

The row showing identity, if it is in the tree.

Keyed on the full identity, so a reused PID resolves to nothing rather than to the wrong row (§26).

pub const fn cycles_broken(&self) -> u32

How many parent links were cut to break a cycle, self-parents included.

Zero on any sane system. A non-zero value is worth surfacing as collector health rather than hiding, because it means the process table was read while the graph was inconsistent.

pub fn max_depth(&self) -> u32

The deepest indentation level in the tree.

pub fn subtree_len(&self, index: usize) -> usize

The number of rows this row occupies together with its subtree.

pub fn child_rows(&self, index: usize) -> Vec<usize>

The direct children of a row, in display order (§2.4 child navigation).

pub fn ancestor_rows(&self, index: usize) -> Vec<usize>

The ancestors of a row, nearest parent first (§2.4 breadcrumb).

Terminates because parent_row is always a smaller index than the row it belongs to: pre-order emission guarantees it, so the walk strictly decreases.

pub fn continuation_flags(&self, index: usize) -> Vec<bool>

Whether a vertical continuation line is needed at each level above a row.

Element i covers indentation level i (root-most first) and is true when the ancestor at that level still has siblings below it, so the renderer draws | there and three spaces otherwise. The row’s own connector comes from TreeRow::is_last_child.

pub fn process<'a, P: Borrow<ProcessSnapshot>>( &self, processes: &'a [P], index: usize, ) -> Option<&'a ProcessSnapshot>

The process a row refers to, revalidated against its identity.

Returns None when processes is not the slice the tree was built from, so a stale tree paired with a fresh snapshot yields nothing instead of the wrong process (§26: a PID is not an identity).

pub fn ancestry<P: Borrow<ProcessSnapshot>>( &self, processes: &[P], index: usize, ) -> Vec<AncestorEntry>

The §2.4 ancestry breadcrumb for a row, nearest parent first.

Matches the ordering of crate::model::ProcessDetail::ancestry so the live tree and an on-demand detail read render identically. Entries that cannot be revalidated against processes are skipped rather than guessed.

Trait Implementations

impl Clone for ProcessTree

fn clone(&self) -> ProcessTree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessTree

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

Formats the value using the given formatter.

impl Default for ProcessTree

fn default() -> ProcessTree

Returns the “default value” for a type.