Struct 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 (on Windows it never changes though)
• 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.

⚠️ ** Linux Specific ** ⚠️ When using ProcessRefreshKind::everything(), in linux we will fetch all relevant information from /proc/<pid>/ as well as all the information from /proc/<pid>/task/<tid>/ folders. This makes the refresh mechanism a lot slower depending on the number of tasks each process has.

If you don’t care about tasks information, use ProcessRefreshKind::everything().without_tasks() as much as possible.

use sysinfo::{ProcessesToUpdate, ProcessRefreshKind, System};

let mut system = System::new();

// We don't want to update the CPU information.
system.refresh_processes_specifics(
    ProcessesToUpdate::All,
    true,
    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 nothing() -> ProcessRefreshKind

Creates a new ProcessRefreshKind with every refresh set to false, except for tasks. By default, we want to list all processes and tasks are considered processes on their own in linux so we still fetch them by default. However, the processes information are not refreshed.

use sysinfo::{ProcessRefreshKind, UpdateKind};

let r = ProcessRefreshKind::nothing();

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. It will retrieve both CPU usage and CPU accumulated time,

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::nothing();

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::nothing();

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::nothing();

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::nothing();

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::nothing();
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::nothing();
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::nothing();

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::nothing();

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::nothing();
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::nothing();
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::nothing();
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::nothing();
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::nothing();
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::nothing();
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::nothing();
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::nothing();
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::nothing();
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::nothing();
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);

pub fn tasks(&self) -> bool

Returns the value of the “tasks” refresh kind.

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::nothing();

let r = r.with_tasks();
assert_eq!(r.tasks(), true);

let r = r.without_tasks();
assert_eq!(r.tasks(), false);

pub fn with_tasks(self) -> ProcessRefreshKind

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

use sysinfo::ProcessRefreshKind;

let r = ProcessRefreshKind::nothing();

let r = r.with_tasks();
assert_eq!(r.tasks(), true);

pub fn without_tasks(self) -> ProcessRefreshKind

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

use sysinfo::ProcessRefreshKind;

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

let r = r.without_tasks();
assert_eq!(r.tasks(), false);

Trait Implementations

impl Clone for ProcessRefreshKind

fn clone(&self) -> ProcessRefreshKind

Returns a duplicate 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

Creates a new ProcessRefreshKind with every refresh set to false, except for tasks. By default, we want to list all processes and tasks are considered processes on their own in linux so we still fetch them by default. However, the processes information are not refreshed.

fn default() -> ProcessRefreshKind

Returns the “default value” for a type.

impl PartialEq for ProcessRefreshKind

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

Tests for self and other values to be equal, and is used by ==.

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

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 StructuralPartialEq for ProcessRefreshKind