Struct ProcessSort 

pub struct ProcessSort {
    pub key: ProcessSortKey,
    pub direction: SortDirection,
}

A complete process table ordering: which column, and which way round.

Fields

key: ProcessSortKey

The column being sorted.

direction: SortDirection

The direction of the value comparison.

Implementations

impl ProcessSort

pub const fn new(key: ProcessSortKey, direction: SortDirection) -> Self

Builds an ordering.

pub const fn descending(key: ProcessSortKey) -> Self

Builds a descending ordering, which is what almost every metric column wants: the interesting rows are the big ones.

pub const fn ascending(key: ProcessSortKey) -> Self

Builds an ascending ordering.

pub const fn reversed(self) -> Self

The same column, sorted the other way round (S, §6.2).

pub const fn with_key(self, key: ProcessSortKey) -> Self

A different column, keeping the current direction.

Picking a column from the selector (s, §6.2) must not silently flip the direction as well; §7.2 forbids the table rearranging in ways the user did not ask for.

pub fn compare( &self, left: &ProcessSnapshot, right: &ProcessSnapshot, ) -> Ordering

Compares two processes under this ordering.

A total order: reflexive, antisymmetric, and transitive, with the identity tie-break guaranteeing that only genuinely identical processes compare Ordering::Equal. That is what makes it safe to hand to slice::sort_by and what keeps two refreshes of the same table in the same order (§7.2).

pub fn sort<P: Borrow<ProcessSnapshot>>(&self, rows: &mut [P])

Sorts rows in place under this ordering.

Generic over Borrow so it works on an owned Vec<ProcessSnapshot> and on a borrowed Vec<&ProcessSnapshot> alike.

pub fn order<P: Borrow<ProcessSnapshot>>(&self, rows: &[P]) -> Vec<usize>

The display order of rows, as indices into rows.

Returning indices keeps the published snapshot immutable (§10.4) and avoids cloning a process table that can hold ten thousand rows (§16.1).

Trait Implementations

impl Clone for ProcessSort

fn clone(&self) -> ProcessSort

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ProcessSort

impl Debug for ProcessSort

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

Formats the value using the given formatter.

impl Default for ProcessSort

fn default() -> ProcessSort

Returns the “default value” for a type.

impl Eq for ProcessSort

impl Hash for ProcessSort

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ProcessSort

fn eq(&self, other: &ProcessSort) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ProcessSort