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.

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.

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.

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);

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

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