Struct vergen::ProcessRefreshKind

pub struct ProcessRefreshKind { /* private fields */ }

Available on crate feature si only.

Used to determine what you want to refresh specifically on the Process type.

When all refresh are ruled out, a Process will still retrieve the following information:

• Process ID (Pid)
• Parent process ID
• Process name
• Start time

⚠️ Just like all other refresh types, ruling out a refresh doesn’t assure you that the information won’t be retrieved if the information is accessible without needing extra computation.

use sysinfo::{ProcessRefreshKind, System};

let mut system = System::new();

// We don't want to update the CPU information.
system.refresh_processes_specifics(ProcessRefreshKind::everything().without_cpu());

for (_, proc_) in system.processes() {
    // We use a `==` comparison on float only because we know it's set to 0 here.
    assert_eq!(proc_.cpu_usage(), 0.);
}

Implementations

impl ProcessRefreshKind

pub fn new() -> ProcessRefreshKind

Creates a new ProcessRefreshKind with every refresh set to false.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();

assert_eq!(r.cpu(), false);
assert_eq!(r.user(), UpdateKind::Never);

pub fn everything() -> ProcessRefreshKind

Creates a new ProcessRefreshKind with every refresh set to true or UpdateKind::OnlyIfNotSet.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::everything();

assert_eq!(r.cpu(), true);
assert_eq!(r.user(), UpdateKind::OnlyIfNotSet);

pub fn cpu(&self) -> bool

Returns the value of the “cpu” refresh kind.

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::new();
assert_eq!(r.cpu(), false);

let r = r.with_cpu();
assert_eq!(r.cpu(), true);

let r = r.without_cpu();
assert_eq!(r.cpu(), false);

pub fn with_cpu(self) -> ProcessRefreshKind

Sets the value of the “cpu” refresh kind to true.

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::new();
assert_eq!(r.cpu(), false);

let r = r.with_cpu();
assert_eq!(r.cpu(), true);

pub fn without_cpu(self) -> ProcessRefreshKind

Sets the value of the “cpu” refresh kind to false.

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::everything();
assert_eq!(r.cpu(), true);

let r = r.without_cpu();
assert_eq!(r.cpu(), false);

pub fn disk_usage(&self) -> bool

Returns the value of the “disk_usage” refresh kind.

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::new();
assert_eq!(r.disk_usage(), false);

let r = r.with_disk_usage();
assert_eq!(r.disk_usage(), true);

let r = r.without_disk_usage();
assert_eq!(r.disk_usage(), false);

pub fn with_disk_usage(self) -> ProcessRefreshKind

Sets the value of the “disk_usage” refresh kind to true.

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::new();
assert_eq!(r.disk_usage(), false);

let r = r.with_disk_usage();
assert_eq!(r.disk_usage(), true);

pub fn without_disk_usage(self) -> ProcessRefreshKind

Sets the value of the “disk_usage” refresh kind to false.

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::everything();
assert_eq!(r.disk_usage(), true);

let r = r.without_disk_usage();
assert_eq!(r.disk_usage(), false);

pub fn user(&self) -> UpdateKind

Returns the value of the “user” refresh kind. It will retrieve the following information:

• user ID
• user effective ID (if available on the platform)
• user group ID (if available on the platform)
• user effective ID (if available on the platform)

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.user(), UpdateKind::Never);

let r = r.with_user(UpdateKind::OnlyIfNotSet);
assert_eq!(r.user(), UpdateKind::OnlyIfNotSet);

let r = r.without_user();
assert_eq!(r.user(), UpdateKind::Never);

pub fn with_user(self, kind: UpdateKind) -> ProcessRefreshKind

Sets the value of the “user” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.user(), UpdateKind::Never);

let r = r.with_user(UpdateKind::OnlyIfNotSet);
assert_eq!(r.user(), UpdateKind::OnlyIfNotSet);

pub fn without_user(self) -> ProcessRefreshKind

Sets the value of the “user” refresh kind to UpdateKind::Never.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::everything();
assert_eq!(r.user(), UpdateKind::OnlyIfNotSet);

let r = r.without_user();
assert_eq!(r.user(), UpdateKind::Never);

pub fn memory(&self) -> bool

Returns the value of the “memory” refresh kind.

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::new();
assert_eq!(r.memory(), false);

let r = r.with_memory();
assert_eq!(r.memory(), true);

let r = r.without_memory();
assert_eq!(r.memory(), false);

pub fn with_memory(self) -> ProcessRefreshKind

Sets the value of the “memory” refresh kind to true.

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::new();
assert_eq!(r.memory(), false);

let r = r.with_memory();
assert_eq!(r.memory(), true);

pub fn without_memory(self) -> ProcessRefreshKind

Sets the value of the “memory” refresh kind to false.

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::everything();
assert_eq!(r.memory(), true);

let r = r.without_memory();
assert_eq!(r.memory(), false);

pub fn cwd(&self) -> UpdateKind

Returns the value of the “cwd” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.cwd(), UpdateKind::Never);

let r = r.with_cwd(UpdateKind::OnlyIfNotSet);
assert_eq!(r.cwd(), UpdateKind::OnlyIfNotSet);

let r = r.without_cwd();
assert_eq!(r.cwd(), UpdateKind::Never);

pub fn with_cwd(self, kind: UpdateKind) -> ProcessRefreshKind

Sets the value of the “cwd” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.cwd(), UpdateKind::Never);

let r = r.with_cwd(UpdateKind::OnlyIfNotSet);
assert_eq!(r.cwd(), UpdateKind::OnlyIfNotSet);

pub fn without_cwd(self) -> ProcessRefreshKind

Sets the value of the “cwd” refresh kind to UpdateKind::Never.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::everything();
assert_eq!(r.cwd(), UpdateKind::OnlyIfNotSet);

let r = r.without_cwd();
assert_eq!(r.cwd(), UpdateKind::Never);

pub fn root(&self) -> UpdateKind

Returns the value of the “root” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.root(), UpdateKind::Never);

let r = r.with_root(UpdateKind::OnlyIfNotSet);
assert_eq!(r.root(), UpdateKind::OnlyIfNotSet);

let r = r.without_root();
assert_eq!(r.root(), UpdateKind::Never);

pub fn with_root(self, kind: UpdateKind) -> ProcessRefreshKind

Sets the value of the “root” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.root(), UpdateKind::Never);

let r = r.with_root(UpdateKind::OnlyIfNotSet);
assert_eq!(r.root(), UpdateKind::OnlyIfNotSet);

pub fn without_root(self) -> ProcessRefreshKind

Sets the value of the “root” refresh kind to UpdateKind::Never.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::everything();
assert_eq!(r.root(), UpdateKind::OnlyIfNotSet);

let r = r.without_root();
assert_eq!(r.root(), UpdateKind::Never);

pub fn environ(&self) -> UpdateKind

Returns the value of the “environ” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.environ(), UpdateKind::Never);

let r = r.with_environ(UpdateKind::OnlyIfNotSet);
assert_eq!(r.environ(), UpdateKind::OnlyIfNotSet);

let r = r.without_environ();
assert_eq!(r.environ(), UpdateKind::Never);

pub fn with_environ(self, kind: UpdateKind) -> ProcessRefreshKind

Sets the value of the “environ” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.environ(), UpdateKind::Never);

let r = r.with_environ(UpdateKind::OnlyIfNotSet);
assert_eq!(r.environ(), UpdateKind::OnlyIfNotSet);

pub fn without_environ(self) -> ProcessRefreshKind

Sets the value of the “environ” refresh kind to UpdateKind::Never.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::everything();
assert_eq!(r.environ(), UpdateKind::OnlyIfNotSet);

let r = r.without_environ();
assert_eq!(r.environ(), UpdateKind::Never);

pub fn cmd(&self) -> UpdateKind

Returns the value of the “cmd” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.cmd(), UpdateKind::Never);

let r = r.with_cmd(UpdateKind::OnlyIfNotSet);
assert_eq!(r.cmd(), UpdateKind::OnlyIfNotSet);

let r = r.without_cmd();
assert_eq!(r.cmd(), UpdateKind::Never);

pub fn with_cmd(self, kind: UpdateKind) -> ProcessRefreshKind

Sets the value of the “cmd” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.cmd(), UpdateKind::Never);

let r = r.with_cmd(UpdateKind::OnlyIfNotSet);
assert_eq!(r.cmd(), UpdateKind::OnlyIfNotSet);

pub fn without_cmd(self) -> ProcessRefreshKind

Sets the value of the “cmd” refresh kind to UpdateKind::Never.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::everything();
assert_eq!(r.cmd(), UpdateKind::OnlyIfNotSet);

let r = r.without_cmd();
assert_eq!(r.cmd(), UpdateKind::Never);

pub fn exe(&self) -> UpdateKind

Returns the value of the “exe” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.exe(), UpdateKind::Never);

let r = r.with_exe(UpdateKind::OnlyIfNotSet);
assert_eq!(r.exe(), UpdateKind::OnlyIfNotSet);

let r = r.without_exe();
assert_eq!(r.exe(), UpdateKind::Never);

pub fn with_exe(self, kind: UpdateKind) -> ProcessRefreshKind

Sets the value of the “exe” refresh kind.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::new();
assert_eq!(r.exe(), UpdateKind::Never);

let r = r.with_exe(UpdateKind::OnlyIfNotSet);
assert_eq!(r.exe(), UpdateKind::OnlyIfNotSet);

pub fn without_exe(self) -> ProcessRefreshKind

Sets the value of the “exe” refresh kind to UpdateKind::Never.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::everything();
assert_eq!(r.exe(), UpdateKind::OnlyIfNotSet);

let r = r.without_exe();
assert_eq!(r.exe(), UpdateKind::Never);

Trait Implementations

impl Clone for ProcessRefreshKind

fn clone(&self) -> ProcessRefreshKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessRefreshKind

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

Formats the value using the given formatter.

impl Default for ProcessRefreshKind

fn default() -> ProcessRefreshKind

Returns the “default value” for a type.

impl PartialEq for ProcessRefreshKind

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ProcessRefreshKind

impl Eq for ProcessRefreshKind

impl StructuralEq for ProcessRefreshKind

impl StructuralPartialEq for ProcessRefreshKind