Struct sysinfo::ProcessRefreshKind

source ·

pub struct ProcessRefreshKind { /* private fields */ }

Expand description

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::{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§

source §

impl ProcessRefreshKind

source

pub fn new() -> Self

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

source

pub fn everything() -> Self

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

source

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

source

pub fn with_cpu(self) -> Self

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

source

pub fn without_cpu(self) -> Self

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

source

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

source

pub fn with_disk_usage(self) -> Self

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

source

pub fn without_disk_usage(self) -> Self

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

source

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

source

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

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

source

pub fn without_user(self) -> Self

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

source

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

source

pub fn with_memory(self) -> Self

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

source

pub fn without_memory(self) -> Self

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

source

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

source

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

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

source

pub fn without_cwd(self) -> Self

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

source

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

source

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

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

source

pub fn without_root(self) -> Self

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

source

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

source

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

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

source

pub fn without_environ(self) -> Self

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

source

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

source

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

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

source

pub fn without_cmd(self) -> Self

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

source

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

source

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

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

source

pub fn without_exe(self) -> Self

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